#![doc = "generated by AutoRust"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
#[doc = "Credential details of the account."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AccountCredentialDetails {
    #[doc = "Name of the account."]
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[doc = "Data Destination Type."]
    #[serde(rename = "dataDestinationType", default, skip_serializing_if = "Option::is_none")]
    pub data_destination_type: Option<account_credential_details::DataDestinationType>,
    #[doc = "Connection string of the account endpoint to use the account as a storage endpoint on the device."]
    #[serde(rename = "accountConnectionString", default, skip_serializing_if = "Option::is_none")]
    pub account_connection_string: Option<String>,
    #[doc = "Per share level unencrypted access credentials."]
    #[serde(rename = "shareCredentialDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub share_credential_details: Vec<ShareCredentialDetails>,
}
impl AccountCredentialDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod account_credential_details {
    use super::*;
    #[doc = "Data Destination Type."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataDestinationType {
        StorageAccount,
        ManagedDisk,
    }
}
#[doc = "Output of the address validation api."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AddressValidationOutput {
    #[doc = "The address validation output."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<AddressValidationProperties>,
}
impl AddressValidationOutput {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "The address validation output."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddressValidationProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "The address validation status."]
    #[serde(rename = "validationStatus", default, skip_serializing_if = "Option::is_none")]
    pub validation_status: Option<address_validation_properties::ValidationStatus>,
    #[doc = "List of alternate addresses."]
    #[serde(rename = "alternateAddresses", default, skip_serializing_if = "Vec::is_empty")]
    pub alternate_addresses: Vec<ShippingAddress>,
}
impl AddressValidationProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            validation_status: None,
            alternate_addresses: Vec::new(),
        }
    }
}
pub mod address_validation_properties {
    use super::*;
    #[doc = "The address validation status."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationStatus {
        Valid,
        Invalid,
        Ambiguous,
    }
}
#[doc = "The Network Adapter configuration of a DataBox."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ApplianceNetworkConfiguration {
    #[doc = "Name of the network."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[doc = "Mac Address."]
    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
    pub mac_address: Option<String>,
}
impl ApplianceNetworkConfiguration {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Base class for all objects under resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ArmBaseObject {
    #[doc = "Name of the object."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[doc = "Id of the object."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[doc = "Type of the object."]
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
}
impl ArmBaseObject {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "The filters for showing the available skus."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AvailableSkuRequest {
    #[doc = "Type of the transfer."]
    #[serde(rename = "transferType")]
    pub transfer_type: available_sku_request::TransferType,
    #[doc = "ISO country code. Country for hardware shipment. For codes check: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements"]
    pub country: String,
    #[doc = "Location for data transfer. For locations check: https://management.azure.com/subscriptions/SUBSCRIPTIONID/locations?api-version=2018-01-01"]
    pub location: String,
    #[doc = "Sku Names to filter for available skus"]
    #[serde(rename = "skuNames", default, skip_serializing_if = "Vec::is_empty")]
    pub sku_names: Vec<String>,
}
impl AvailableSkuRequest {
    pub fn new(transfer_type: available_sku_request::TransferType, country: String, location: String) -> Self {
        Self {
            transfer_type,
            country,
            location,
            sku_names: Vec::new(),
        }
    }
}
pub mod available_sku_request {
    use super::*;
    #[doc = "Type of the transfer."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
    }
}
#[doc = "The available skus operation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AvailableSkusResult {
    #[doc = "List of available skus."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<SkuInformation>,
    #[doc = "Link for the next set of skus."]
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl AvailableSkusResult {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Reason for cancellation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CancellationReason {
    #[doc = "Reason for cancellation."]
    pub reason: String,
}
impl CancellationReason {
    pub fn new(reason: String) -> Self {
        Self { reason }
    }
}
#[doc = "The error information object."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CloudError {
    #[doc = "Error code string."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[doc = "Descriptive error information."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[doc = "Error target"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    #[doc = "More detailed error information."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub details: Vec<CloudError>,
}
impl CloudError {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Contact Details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ContactDetails {
    #[doc = "Contact name of the person."]
    #[serde(rename = "contactName")]
    pub contact_name: String,
    #[doc = "Phone number of the contact person."]
    pub phone: String,
    #[doc = "Phone extension number of the contact person."]
    #[serde(rename = "phoneExtension", default, skip_serializing_if = "Option::is_none")]
    pub phone_extension: Option<String>,
    #[doc = "Mobile number of the contact person."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mobile: Option<String>,
    #[doc = "List of Email-ids to be notified about job progress."]
    #[serde(rename = "emailList")]
    pub email_list: Vec<String>,
    #[doc = "Notification preference for a job stage."]
    #[serde(rename = "notificationPreference", default, skip_serializing_if = "Vec::is_empty")]
    pub notification_preference: Vec<NotificationPreference>,
}
impl ContactDetails {
    pub fn new(contact_name: String, phone: String, email_list: Vec<String>) -> Self {
        Self {
            contact_name,
            phone,
            phone_extension: None,
            mobile: None,
            email_list,
            notification_preference: Vec::new(),
        }
    }
}
#[doc = "Details for log generated during copy."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CopyLogDetails {
    #[doc = "Indicates the type of job details."]
    #[serde(rename = "copyLogDetailsType")]
    pub copy_log_details_type: copy_log_details::CopyLogDetailsType,
}
impl CopyLogDetails {
    pub fn new(copy_log_details_type: copy_log_details::CopyLogDetailsType) -> Self {
        Self { copy_log_details_type }
    }
}
pub mod copy_log_details {
    use super::*;
    #[doc = "Indicates the type of job details."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum CopyLogDetailsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Copy progress."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CopyProgress {
    #[doc = "Name of the storage account where the data needs to be uploaded."]
    #[serde(rename = "storageAccountName", default, skip_serializing_if = "Option::is_none")]
    pub storage_account_name: Option<String>,
    #[doc = "Data Destination Type."]
    #[serde(rename = "dataDestinationType", default, skip_serializing_if = "Option::is_none")]
    pub data_destination_type: Option<copy_progress::DataDestinationType>,
    #[doc = "Id of the account where the data needs to be uploaded."]
    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[doc = "Amount of data uploaded by the job as of now."]
    #[serde(rename = "bytesSentToCloud", default, skip_serializing_if = "Option::is_none")]
    pub bytes_sent_to_cloud: Option<i64>,
    #[doc = "Total amount of data to be processed by the job."]
    #[serde(rename = "totalBytesToProcess", default, skip_serializing_if = "Option::is_none")]
    pub total_bytes_to_process: Option<i64>,
    #[doc = "Number of files processed by the job as of now."]
    #[serde(rename = "filesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub files_processed: Option<i64>,
    #[doc = "Total number of files to be processed by the job."]
    #[serde(rename = "totalFilesToProcess", default, skip_serializing_if = "Option::is_none")]
    pub total_files_to_process: Option<i64>,
    #[doc = "Number of files not adhering to azure naming conventions which were processed by automatic renaming"]
    #[serde(rename = "invalidFilesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub invalid_files_processed: Option<i64>,
    #[doc = "Total amount of data not adhering to azure naming conventions which were processed by automatic renaming"]
    #[serde(rename = "invalidFileBytesUploaded", default, skip_serializing_if = "Option::is_none")]
    pub invalid_file_bytes_uploaded: Option<i64>,
    #[doc = "Number of folders not adhering to azure naming conventions which were processed by automatic renaming"]
    #[serde(rename = "renamedContainerCount", default, skip_serializing_if = "Option::is_none")]
    pub renamed_container_count: Option<i64>,
    #[doc = "Number of files which could not be copied"]
    #[serde(rename = "filesErroredOut", default, skip_serializing_if = "Option::is_none")]
    pub files_errored_out: Option<i64>,
}
impl CopyProgress {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod copy_progress {
    use super::*;
    #[doc = "Data Destination Type."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataDestinationType {
        StorageAccount,
        ManagedDisk,
    }
}
#[doc = "It does all pre-job creation validations."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateJobValidations {
    #[serde(flatten)]
    pub validation_request: ValidationRequest,
}
impl CreateJobValidations {
    pub fn new(validation_request: ValidationRequest) -> Self {
        Self { validation_request }
    }
}
#[doc = "Request to validate create order limit for current subscription."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateOrderLimitForSubscriptionValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[doc = "Device type to be used for the job."]
    #[serde(rename = "deviceType")]
    pub device_type: create_order_limit_for_subscription_validation_request::DeviceType,
}
impl CreateOrderLimitForSubscriptionValidationRequest {
    pub fn new(
        validation_input_request: ValidationInputRequest,
        device_type: create_order_limit_for_subscription_validation_request::DeviceType,
    ) -> Self {
        Self {
            validation_input_request,
            device_type,
        }
    }
}
pub mod create_order_limit_for_subscription_validation_request {
    use super::*;
    #[doc = "Device type to be used for the job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Properties of create order limit for subscription validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateOrderLimitForSubscriptionValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "Create order limit validation status."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<create_order_limit_for_subscription_validation_response_properties::Status>,
}
impl CreateOrderLimitForSubscriptionValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod create_order_limit_for_subscription_validation_response_properties {
    use super::*;
    #[doc = "Create order limit validation status."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[doc = "Copy log details for a storage account of a DataBox job"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxAccountCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[doc = "Destination account name."]
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[doc = "Link for copy logs."]
    #[serde(rename = "copyLogLink", default, skip_serializing_if = "Option::is_none")]
    pub copy_log_link: Option<String>,
}
impl DataBoxAccountCopyLogDetails {
    pub fn new(copy_log_details: CopyLogDetails) -> Self {
        Self {
            copy_log_details,
            account_name: None,
            copy_log_link: None,
        }
    }
}
#[doc = "Copy Log Details for a disk"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[doc = "Disk Serial Number."]
    #[serde(rename = "diskSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub disk_serial_number: Option<String>,
    #[doc = "Link for copy error logs."]
    #[serde(rename = "errorLogLink", default, skip_serializing_if = "Option::is_none")]
    pub error_log_link: Option<String>,
    #[doc = "Link for copy verbose logs."]
    #[serde(rename = "verboseLogLink", default, skip_serializing_if = "Option::is_none")]
    pub verbose_log_link: Option<String>,
}
impl DataBoxDiskCopyLogDetails {
    pub fn new(copy_log_details: CopyLogDetails) -> Self {
        Self {
            copy_log_details,
            disk_serial_number: None,
            error_log_link: None,
            verbose_log_link: None,
        }
    }
}
#[doc = "DataBox Disk Copy Progress"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxDiskCopyProgress {
    #[doc = "The serial number of the disk"]
    #[serde(rename = "serialNumber", default, skip_serializing_if = "Option::is_none")]
    pub serial_number: Option<String>,
    #[doc = "Bytes copied during the copy of disk."]
    #[serde(rename = "bytesCopied", default, skip_serializing_if = "Option::is_none")]
    pub bytes_copied: Option<i64>,
    #[doc = "Indicates the percentage completed for the copy of the disk."]
    #[serde(rename = "percentComplete", default, skip_serializing_if = "Option::is_none")]
    pub percent_complete: Option<i32>,
    #[doc = "The Status of the copy"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<data_box_disk_copy_progress::Status>,
}
impl DataBoxDiskCopyProgress {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod data_box_disk_copy_progress {
    use super::*;
    #[doc = "The Status of the copy"]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        NotStarted,
        InProgress,
        Completed,
        CompletedWithErrors,
        Failed,
        NotReturned,
        HardwareError,
        DeviceFormatted,
        DeviceMetadataModified,
        StorageAccountNotAccessible,
        UnsupportedData,
    }
}
#[doc = "DataBox Disk Job Details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[doc = "User preference on what size disks are needed for the job. The map is from the disk size in TB to the count. Eg. {2,5} means 5 disks of 2 TB size. Key is string but will be checked against an int."]
    #[serde(rename = "preferredDisks", default, skip_serializing_if = "Option::is_none")]
    pub preferred_disks: Option<serde_json::Value>,
    #[doc = "Copy progress per disk."]
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<DataBoxDiskCopyProgress>,
    #[doc = "Contains the map of disk serial number to the disk size being used for the job. Is returned only after the disks are shipped to the customer."]
    #[serde(rename = "disksAndSizeDetails", default, skip_serializing_if = "Option::is_none")]
    pub disks_and_size_details: Option<serde_json::Value>,
    #[doc = "User entered passkey for DataBox Disk job."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub passkey: Option<String>,
}
impl DataBoxDiskJobDetails {
    pub fn new(job_details: JobDetails) -> Self {
        Self {
            job_details,
            preferred_disks: None,
            copy_progress: Vec::new(),
            disks_and_size_details: None,
            passkey: None,
        }
    }
}
#[doc = "The secrets related to disk job."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[doc = "Contains the list of secrets object for that device."]
    #[serde(rename = "diskSecrets", default, skip_serializing_if = "Vec::is_empty")]
    pub disk_secrets: Vec<DiskSecret>,
    #[doc = "PassKey for the disk Job."]
    #[serde(rename = "passKey", default, skip_serializing_if = "Option::is_none")]
    pub pass_key: Option<String>,
    #[doc = "Whether passkey was provided by user."]
    #[serde(rename = "isPasskeyUserDefined", default, skip_serializing_if = "Option::is_none")]
    pub is_passkey_user_defined: Option<bool>,
}
impl DataBoxDiskJobSecrets {
    pub fn new(job_secrets: JobSecrets) -> Self {
        Self {
            job_secrets,
            disk_secrets: Vec::new(),
            pass_key: None,
            is_passkey_user_defined: None,
        }
    }
}
#[doc = "Copy log details for a storage account for Databox heavy"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyAccountCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[doc = "Destination account name."]
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[doc = "Link for copy logs."]
    #[serde(rename = "copyLogLink", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_log_link: Vec<String>,
}
impl DataBoxHeavyAccountCopyLogDetails {
    pub fn new(copy_log_details: CopyLogDetails) -> Self {
        Self {
            copy_log_details,
            account_name: None,
            copy_log_link: Vec::new(),
        }
    }
}
#[doc = "Databox Heavy Device Job Details"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[doc = "Copy progress per account."]
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<CopyProgress>,
    #[doc = "Set Device password for unlocking Databox Heavy"]
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
}
impl DataBoxHeavyJobDetails {
    pub fn new(job_details: JobDetails) -> Self {
        Self {
            job_details,
            copy_progress: Vec::new(),
            device_password: None,
        }
    }
}
#[doc = "The secrets related to a databox heavy job."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[doc = "Contains the list of secret objects for a databox heavy job."]
    #[serde(rename = "cabinetPodSecrets", default, skip_serializing_if = "Vec::is_empty")]
    pub cabinet_pod_secrets: Vec<DataBoxHeavySecret>,
}
impl DataBoxHeavyJobSecrets {
    pub fn new(job_secrets: JobSecrets) -> Self {
        Self {
            job_secrets,
            cabinet_pod_secrets: Vec::new(),
        }
    }
}
#[doc = "The secrets related to a databox heavy."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxHeavySecret {
    #[doc = "Serial number of the assigned device."]
    #[serde(rename = "deviceSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub device_serial_number: Option<String>,
    #[doc = "Password for out of the box experience on device."]
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
    #[doc = "Network configuration of the appliance."]
    #[serde(rename = "networkConfigurations", default, skip_serializing_if = "Vec::is_empty")]
    pub network_configurations: Vec<ApplianceNetworkConfiguration>,
    #[doc = "The base 64 encoded public key to authenticate with the device"]
    #[serde(rename = "encodedValidationCertPubKey", default, skip_serializing_if = "Option::is_none")]
    pub encoded_validation_cert_pub_key: Option<String>,
    #[doc = "Per account level access credentials."]
    #[serde(rename = "accountCredentialDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub account_credential_details: Vec<AccountCredentialDetails>,
}
impl DataBoxHeavySecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Databox Job Details"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[doc = "Copy progress per storage account."]
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<CopyProgress>,
    #[doc = "Set Device password for unlocking Databox"]
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
}
impl DataBoxJobDetails {
    pub fn new(job_details: JobDetails) -> Self {
        Self {
            job_details,
            copy_progress: Vec::new(),
            device_password: None,
        }
    }
}
#[doc = "Request body to get the availability for scheduling data box orders orders."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxScheduleAvailabilityRequest {
    #[serde(flatten)]
    pub schedule_availability_request: ScheduleAvailabilityRequest,
}
impl DataBoxScheduleAvailabilityRequest {
    pub fn new(schedule_availability_request: ScheduleAvailabilityRequest) -> Self {
        Self {
            schedule_availability_request,
        }
    }
}
#[doc = "The secrets related to a DataBox."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxSecret {
    #[doc = "Serial number of the assigned device."]
    #[serde(rename = "deviceSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub device_serial_number: Option<String>,
    #[doc = "Password for out of the box experience on device."]
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
    #[doc = "Network configuration of the appliance."]
    #[serde(rename = "networkConfigurations", default, skip_serializing_if = "Vec::is_empty")]
    pub network_configurations: Vec<ApplianceNetworkConfiguration>,
    #[doc = "The base 64 encoded public key to authenticate with the device"]
    #[serde(rename = "encodedValidationCertPubKey", default, skip_serializing_if = "Option::is_none")]
    pub encoded_validation_cert_pub_key: Option<String>,
    #[doc = "Per account level access credentials."]
    #[serde(rename = "accountCredentialDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub account_credential_details: Vec<AccountCredentialDetails>,
}
impl DataBoxSecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Request to validate data destination details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataDestinationDetailsValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[doc = "Destination account details list."]
    #[serde(rename = "destinationAccountDetails")]
    pub destination_account_details: Vec<DestinationAccountDetails>,
    #[doc = "Location of stamp or geo."]
    pub location: String,
}
impl DataDestinationDetailsValidationRequest {
    pub fn new(
        validation_input_request: ValidationInputRequest,
        destination_account_details: Vec<DestinationAccountDetails>,
        location: String,
    ) -> Self {
        Self {
            validation_input_request,
            destination_account_details,
            location,
        }
    }
}
#[doc = "Properties of data destination details validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataDestinationDetailsValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "Data destination details validation status."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<data_destination_details_validation_response_properties::Status>,
}
impl DataDestinationDetailsValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod data_destination_details_validation_response_properties {
    use super::*;
    #[doc = "Data destination details validation status."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[doc = "The secrets related to a databox job."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataboxJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[doc = "Contains the list of secret objects for a job."]
    #[serde(rename = "podSecrets", default, skip_serializing_if = "Vec::is_empty")]
    pub pod_secrets: Vec<DataBoxSecret>,
}
impl DataboxJobSecrets {
    pub fn new(job_secrets: JobSecrets) -> Self {
        Self {
            job_secrets,
            pod_secrets: Vec::new(),
        }
    }
}
#[doc = "Dc Access Security code for device."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DcAccessSecurityCode {
    #[doc = "Dc Access Code for dispatching from DC."]
    #[serde(rename = "forwardDCAccessCode", default, skip_serializing_if = "Option::is_none")]
    pub forward_dc_access_code: Option<String>,
    #[doc = "Dc Access code for dropping off at DC."]
    #[serde(rename = "reverseDCAccessCode", default, skip_serializing_if = "Option::is_none")]
    pub reverse_dc_access_code: Option<String>,
}
impl DcAccessSecurityCode {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Details of the destination storage accounts."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DestinationAccountDetails {
    #[doc = "Data Destination Type."]
    #[serde(rename = "dataDestinationType")]
    pub data_destination_type: destination_account_details::DataDestinationType,
    #[doc = "Arm Id of the destination where the data has to be moved."]
    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[doc = "Share password to be shared by all shares in SA."]
    #[serde(rename = "sharePassword", default, skip_serializing_if = "Option::is_none")]
    pub share_password: Option<String>,
}
impl DestinationAccountDetails {
    pub fn new(data_destination_type: destination_account_details::DataDestinationType) -> Self {
        Self {
            data_destination_type,
            account_id: None,
            share_password: None,
        }
    }
}
pub mod destination_account_details {
    use super::*;
    #[doc = "Data Destination Type."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataDestinationType {
        StorageAccount,
        ManagedDisk,
    }
}
#[doc = "Details for the destination compute disks."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DestinationManagedDiskDetails {
    #[serde(flatten)]
    pub destination_account_details: DestinationAccountDetails,
    #[doc = "Destination Resource Group Id where the Compute disks should be created."]
    #[serde(rename = "resourceGroupId")]
    pub resource_group_id: String,
    #[doc = "Arm Id of the storage account that can be used to copy the vhd for staging."]
    #[serde(rename = "stagingStorageAccountId")]
    pub staging_storage_account_id: String,
}
impl DestinationManagedDiskDetails {
    pub fn new(
        destination_account_details: DestinationAccountDetails,
        resource_group_id: String,
        staging_storage_account_id: String,
    ) -> Self {
        Self {
            destination_account_details,
            resource_group_id,
            staging_storage_account_id,
        }
    }
}
#[doc = "Details for the destination storage account."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DestinationStorageAccountDetails {
    #[serde(flatten)]
    pub destination_account_details: DestinationAccountDetails,
    #[doc = "Destination Storage Account Arm Id."]
    #[serde(rename = "storageAccountId")]
    pub storage_account_id: String,
}
impl DestinationStorageAccountDetails {
    pub fn new(destination_account_details: DestinationAccountDetails, storage_account_id: String) -> Self {
        Self {
            destination_account_details,
            storage_account_id,
        }
    }
}
#[doc = "Map of destination location to service location."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DestinationToServiceLocationMap {
    #[doc = "Location of the destination."]
    #[serde(rename = "destinationLocation", default, skip_serializing_if = "Option::is_none")]
    pub destination_location: Option<String>,
    #[doc = "Location of the service."]
    #[serde(rename = "serviceLocation", default, skip_serializing_if = "Option::is_none")]
    pub service_location: Option<String>,
}
impl DestinationToServiceLocationMap {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Request body to get the availability for scheduling disk orders."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DiskScheduleAvailabilityRequest {
    #[serde(flatten)]
    pub schedule_availability_request: ScheduleAvailabilityRequest,
    #[doc = "The expected size of the data, which needs to be transferred in this job, in terabytes."]
    #[serde(rename = "expectedDataSizeInTeraBytes")]
    pub expected_data_size_in_tera_bytes: i32,
}
impl DiskScheduleAvailabilityRequest {
    pub fn new(schedule_availability_request: ScheduleAvailabilityRequest, expected_data_size_in_tera_bytes: i32) -> Self {
        Self {
            schedule_availability_request,
            expected_data_size_in_tera_bytes,
        }
    }
}
#[doc = "Contains all the secrets of a Disk."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiskSecret {
    #[doc = "Serial number of the assigned disk."]
    #[serde(rename = "diskSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub disk_serial_number: Option<String>,
    #[doc = "Bit Locker key of the disk which can be used to unlock the disk to copy data."]
    #[serde(rename = "bitLockerKey", default, skip_serializing_if = "Option::is_none")]
    pub bit_locker_key: Option<String>,
}
impl DiskSecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Top level error for the job."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Error {
    #[doc = "Error code that can be used to programmatically identify the error."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[doc = "Describes the error in detail and provides debugging information."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}
impl Error {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Request body to get the availability for scheduling heavy orders."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct HeavyScheduleAvailabilityRequest {
    #[serde(flatten)]
    pub schedule_availability_request: ScheduleAvailabilityRequest,
}
impl HeavyScheduleAvailabilityRequest {
    pub fn new(schedule_availability_request: ScheduleAvailabilityRequest) -> Self {
        Self {
            schedule_availability_request,
        }
    }
}
#[doc = "Additional delivery info."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobDeliveryInfo {
    #[doc = "Scheduled date time."]
    #[serde(rename = "scheduledDateTime", default, skip_serializing_if = "Option::is_none")]
    pub scheduled_date_time: Option<String>,
}
impl JobDeliveryInfo {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Job details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobDetails {
    #[doc = "The expected size of the data, which needs to be transferred in this job, in terabytes."]
    #[serde(rename = "expectedDataSizeInTeraBytes", default, skip_serializing_if = "Option::is_none")]
    pub expected_data_size_in_tera_bytes: Option<i32>,
    #[doc = "List of stages that run in the job."]
    #[serde(rename = "jobStages", default, skip_serializing_if = "Vec::is_empty")]
    pub job_stages: Vec<JobStages>,
    #[doc = "Contact Details."]
    #[serde(rename = "contactDetails")]
    pub contact_details: ContactDetails,
    #[doc = "Shipping address where customer wishes to receive the device."]
    #[serde(rename = "shippingAddress")]
    pub shipping_address: ShippingAddress,
    #[doc = "Shipping details."]
    #[serde(rename = "deliveryPackage", default, skip_serializing_if = "Option::is_none")]
    pub delivery_package: Option<PackageShippingDetails>,
    #[doc = "Shipping details."]
    #[serde(rename = "returnPackage", default, skip_serializing_if = "Option::is_none")]
    pub return_package: Option<PackageShippingDetails>,
    #[doc = "Destination account details."]
    #[serde(rename = "destinationAccountDetails")]
    pub destination_account_details: Vec<DestinationAccountDetails>,
    #[doc = "Error details for failure. This is optional."]
    #[serde(rename = "errorDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub error_details: Vec<JobErrorDetails>,
    #[doc = "Indicates the type of job details."]
    #[serde(rename = "jobDetailsType")]
    pub job_details_type: job_details::JobDetailsType,
    #[doc = "Preferences related to the order"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preferences: Option<Preferences>,
    #[doc = "List of copy log details."]
    #[serde(rename = "copyLogDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_log_details: Vec<CopyLogDetails>,
    #[doc = "Shared access key to download the return shipment label"]
    #[serde(rename = "reverseShipmentLabelSasKey", default, skip_serializing_if = "Option::is_none")]
    pub reverse_shipment_label_sas_key: Option<String>,
    #[doc = "Shared access key to download the chain of custody logs"]
    #[serde(rename = "chainOfCustodySasKey", default, skip_serializing_if = "Option::is_none")]
    pub chain_of_custody_sas_key: Option<String>,
}
impl JobDetails {
    pub fn new(
        contact_details: ContactDetails,
        shipping_address: ShippingAddress,
        destination_account_details: Vec<DestinationAccountDetails>,
        job_details_type: job_details::JobDetailsType,
    ) -> Self {
        Self {
            expected_data_size_in_tera_bytes: None,
            job_stages: Vec::new(),
            contact_details,
            shipping_address,
            delivery_package: None,
            return_package: None,
            destination_account_details,
            error_details: Vec::new(),
            job_details_type,
            preferences: None,
            copy_log_details: Vec::new(),
            reverse_shipment_label_sas_key: None,
            chain_of_custody_sas_key: None,
        }
    }
}
pub mod job_details {
    use super::*;
    #[doc = "Indicates the type of job details."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum JobDetailsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Job Error Details for providing the information and recommended action."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobErrorDetails {
    #[doc = "Message for the error."]
    #[serde(rename = "errorMessage", default, skip_serializing_if = "Option::is_none")]
    pub error_message: Option<String>,
    #[doc = "Code for the error."]
    #[serde(rename = "errorCode", default, skip_serializing_if = "Option::is_none")]
    pub error_code: Option<i32>,
    #[doc = "Recommended action for the error."]
    #[serde(rename = "recommendedAction", default, skip_serializing_if = "Option::is_none")]
    pub recommended_action: Option<String>,
    #[doc = "Contains the non localized exception message"]
    #[serde(rename = "exceptionMessage", default, skip_serializing_if = "Option::is_none")]
    pub exception_message: Option<String>,
}
impl JobErrorDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Job Properties"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobProperties {
    #[doc = "Describes whether the job is cancellable or not."]
    #[serde(rename = "isCancellable", default, skip_serializing_if = "Option::is_none")]
    pub is_cancellable: Option<bool>,
    #[doc = "Describes whether the job is deletable or not."]
    #[serde(rename = "isDeletable", default, skip_serializing_if = "Option::is_none")]
    pub is_deletable: Option<bool>,
    #[doc = "Describes whether the shipping address is editable or not."]
    #[serde(rename = "isShippingAddressEditable", default, skip_serializing_if = "Option::is_none")]
    pub is_shipping_address_editable: Option<bool>,
    #[doc = "Name of the stage which is in progress."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<job_properties::Status>,
    #[doc = "Time at which the job was started in UTC ISO 8601 format."]
    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
    pub start_time: Option<String>,
    #[doc = "Top level error for the job."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<Error>,
    #[doc = "Job details."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<JobDetails>,
    #[doc = "Reason for cancellation."]
    #[serde(rename = "cancellationReason", default, skip_serializing_if = "Option::is_none")]
    pub cancellation_reason: Option<String>,
    #[doc = "Delivery type of Job."]
    #[serde(rename = "deliveryType", default, skip_serializing_if = "Option::is_none")]
    pub delivery_type: Option<job_properties::DeliveryType>,
    #[doc = "Additional delivery info."]
    #[serde(rename = "deliveryInfo", default, skip_serializing_if = "Option::is_none")]
    pub delivery_info: Option<JobDeliveryInfo>,
    #[doc = "Flag to indicate cancellation of scheduled job."]
    #[serde(rename = "isCancellableWithoutFee", default, skip_serializing_if = "Option::is_none")]
    pub is_cancellable_without_fee: Option<bool>,
}
impl JobProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod job_properties {
    use super::*;
    #[doc = "Name of the stage which is in progress."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        DeviceOrdered,
        DevicePrepared,
        Dispatched,
        Delivered,
        PickedUp,
        #[serde(rename = "AtAzureDC")]
        AtAzureDc,
        DataCopy,
        Completed,
        CompletedWithErrors,
        Cancelled,
        #[serde(rename = "Failed_IssueReportedAtCustomer")]
        FailedIssueReportedAtCustomer,
        #[serde(rename = "Failed_IssueDetectedAtAzureDC")]
        FailedIssueDetectedAtAzureDc,
        Aborted,
        CompletedWithWarnings,
        #[serde(rename = "ReadyToDispatchFromAzureDC")]
        ReadyToDispatchFromAzureDc,
        #[serde(rename = "ReadyToReceiveAtAzureDC")]
        ReadyToReceiveAtAzureDc,
    }
    #[doc = "Delivery type of Job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeliveryType {
        NonScheduled,
        Scheduled,
    }
    impl Default for DeliveryType {
        fn default() -> Self {
            Self::NonScheduled
        }
    }
}
#[doc = "Job Resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobResource {
    #[serde(flatten)]
    pub resource: Resource,
    #[doc = "Job Properties"]
    pub properties: JobProperties,
    #[doc = "Name of the object."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[doc = "Id of the object."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[doc = "Type of the object."]
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
}
impl JobResource {
    pub fn new(resource: Resource, properties: JobProperties) -> Self {
        Self {
            resource,
            properties,
            name: None,
            id: None,
            type_: None,
        }
    }
}
#[doc = "Job Resource Collection"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobResourceList {
    #[doc = "List of job resources."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<JobResource>,
    #[doc = "Link for the next set of job resources."]
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl JobResourceList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "The JobResourceUpdateParameter."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobResourceUpdateParameter {
    #[doc = "Job Properties for update"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<UpdateJobProperties>,
    #[doc = "The list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups)."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<serde_json::Value>,
}
impl JobResourceUpdateParameter {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "The base class for the secrets"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobSecrets {
    #[doc = "Used to indicate what type of job secrets object."]
    #[serde(rename = "jobSecretsType")]
    pub job_secrets_type: job_secrets::JobSecretsType,
    #[doc = "Dc Access Security code for device."]
    #[serde(rename = "dcAccessSecurityCode", default, skip_serializing_if = "Option::is_none")]
    pub dc_access_security_code: Option<DcAccessSecurityCode>,
}
impl JobSecrets {
    pub fn new(job_secrets_type: job_secrets::JobSecretsType) -> Self {
        Self {
            job_secrets_type,
            dc_access_security_code: None,
        }
    }
}
pub mod job_secrets {
    use super::*;
    #[doc = "Used to indicate what type of job secrets object."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum JobSecretsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Job stages."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobStages {
    #[doc = "Name of the job stage."]
    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
    pub stage_name: Option<job_stages::StageName>,
    #[doc = "Display name of the job stage."]
    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    #[doc = "Status of the job stage."]
    #[serde(rename = "stageStatus", default, skip_serializing_if = "Option::is_none")]
    pub stage_status: Option<job_stages::StageStatus>,
    #[doc = "Time for the job stage in UTC ISO 8601 format."]
    #[serde(rename = "stageTime", default, skip_serializing_if = "Option::is_none")]
    pub stage_time: Option<String>,
    #[doc = "Job Stage Details"]
    #[serde(rename = "jobStageDetails", default, skip_serializing_if = "Option::is_none")]
    pub job_stage_details: Option<serde_json::Value>,
    #[doc = "Error details for the stage."]
    #[serde(rename = "errorDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub error_details: Vec<JobErrorDetails>,
}
impl JobStages {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod job_stages {
    use super::*;
    #[doc = "Name of the job stage."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum StageName {
        DeviceOrdered,
        DevicePrepared,
        Dispatched,
        Delivered,
        PickedUp,
        #[serde(rename = "AtAzureDC")]
        AtAzureDc,
        DataCopy,
        Completed,
        CompletedWithErrors,
        Cancelled,
        #[serde(rename = "Failed_IssueReportedAtCustomer")]
        FailedIssueReportedAtCustomer,
        #[serde(rename = "Failed_IssueDetectedAtAzureDC")]
        FailedIssueDetectedAtAzureDc,
        Aborted,
        CompletedWithWarnings,
        #[serde(rename = "ReadyToDispatchFromAzureDC")]
        ReadyToDispatchFromAzureDc,
        #[serde(rename = "ReadyToReceiveAtAzureDC")]
        ReadyToReceiveAtAzureDc,
    }
    #[doc = "Status of the job stage."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum StageStatus {
        None,
        InProgress,
        Succeeded,
        Failed,
        Cancelled,
        Cancelling,
        SucceededWithErrors,
    }
}
#[doc = "Notification preference for a job stage."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreference {
    #[doc = "Name of the stage."]
    #[serde(rename = "stageName")]
    pub stage_name: notification_preference::StageName,
    #[doc = "Notification is required or not."]
    #[serde(rename = "sendNotification")]
    pub send_notification: bool,
}
impl NotificationPreference {
    pub fn new(stage_name: notification_preference::StageName, send_notification: bool) -> Self {
        Self {
            stage_name,
            send_notification,
        }
    }
}
pub mod notification_preference {
    use super::*;
    #[doc = "Name of the stage."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum StageName {
        DevicePrepared,
        Dispatched,
        Delivered,
        PickedUp,
        #[serde(rename = "AtAzureDC")]
        AtAzureDc,
        DataCopy,
    }
}
#[doc = "Operation entity."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Operation {
    #[doc = "Name of the operation. Format: {resourceProviderNamespace}/{resourceType}/{read|write|delete|action}"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[doc = "Operation display"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display: Option<OperationDisplay>,
    #[doc = "Operation properties."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<OperationProperties>,
    #[doc = "Origin of the operation. Can be : user|system|user,system"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub origin: Option<String>,
}
impl Operation {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Operation display"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationDisplay {
    #[doc = "Provider name."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[doc = "Resource name."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource: Option<String>,
    #[doc = "Localized name of the operation for display purpose."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operation: Option<String>,
    #[doc = "Localized description of the operation for display purpose."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}
impl OperationDisplay {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Operation Collection."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationList {
    #[doc = "List of operations."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<Operation>,
    #[doc = "Link for the next set of operations."]
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl OperationList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Operation properties."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationProperties {}
impl OperationProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Shipping details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PackageShippingDetails {
    #[doc = "Name of the carrier."]
    #[serde(rename = "carrierName", default, skip_serializing_if = "Option::is_none")]
    pub carrier_name: Option<String>,
    #[doc = "Tracking Id of shipment."]
    #[serde(rename = "trackingId", default, skip_serializing_if = "Option::is_none")]
    pub tracking_id: Option<String>,
    #[doc = "Url where shipment can be tracked."]
    #[serde(rename = "trackingUrl", default, skip_serializing_if = "Option::is_none")]
    pub tracking_url: Option<String>,
}
impl PackageShippingDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Preferences related to the order"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Preferences {
    #[doc = "Preferred Data Center Region."]
    #[serde(rename = "preferredDataCenterRegion", default, skip_serializing_if = "Vec::is_empty")]
    pub preferred_data_center_region: Vec<String>,
    #[doc = "Preferences related to the shipment logistics of the sku"]
    #[serde(rename = "transportPreferences", default, skip_serializing_if = "Option::is_none")]
    pub transport_preferences: Option<TransportPreferences>,
}
impl Preferences {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Request to validate preference of transport and data center."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreferencesValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[doc = "Preferences related to the order"]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preference: Option<Preferences>,
    #[doc = "Device type to be used for the job."]
    #[serde(rename = "deviceType")]
    pub device_type: preferences_validation_request::DeviceType,
}
impl PreferencesValidationRequest {
    pub fn new(validation_input_request: ValidationInputRequest, device_type: preferences_validation_request::DeviceType) -> Self {
        Self {
            validation_input_request,
            preference: None,
            device_type,
        }
    }
}
pub mod preferences_validation_request {
    use super::*;
    #[doc = "Device type to be used for the job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Properties of data center and transport preference validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreferencesValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "Validation status of requested data center and transport."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<preferences_validation_response_properties::Status>,
}
impl PreferencesValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod preferences_validation_response_properties {
    use super::*;
    #[doc = "Validation status of requested data center and transport."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[doc = "Request body to get the configuration for the region."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RegionConfigurationRequest {
    #[doc = "Request body to get the availability for scheduling orders."]
    #[serde(rename = "scheduleAvailabilityRequest", default, skip_serializing_if = "Option::is_none")]
    pub schedule_availability_request: Option<ScheduleAvailabilityRequest>,
    #[doc = "Request body to get the transport availability for given sku."]
    #[serde(rename = "transportAvailabilityRequest", default, skip_serializing_if = "Option::is_none")]
    pub transport_availability_request: Option<TransportAvailabilityRequest>,
}
impl RegionConfigurationRequest {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Configuration response specific to a region."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RegionConfigurationResponse {
    #[doc = "Schedule availability response for given sku in a region."]
    #[serde(rename = "scheduleAvailabilityResponse", default, skip_serializing_if = "Option::is_none")]
    pub schedule_availability_response: Option<ScheduleAvailabilityResponse>,
    #[doc = "Transport options available for given sku in a region."]
    #[serde(rename = "transportAvailabilityResponse", default, skip_serializing_if = "Option::is_none")]
    pub transport_availability_response: Option<TransportAvailabilityResponse>,
}
impl RegionConfigurationResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Model of the Resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource {
    #[doc = "The location of the resource. This will be one of the supported and registered Azure Regions (e.g. West US, East US, Southeast Asia, etc.). The region of a resource cannot be changed once it is created, but if an identical region is specified on update the request will succeed."]
    pub location: String,
    #[doc = "The list of key value pairs that describe the resource. These tags can be used in viewing and grouping this resource (across resource groups)."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<serde_json::Value>,
    #[doc = "The Sku."]
    pub sku: Sku,
}
impl Resource {
    pub fn new(location: String, sku: Sku) -> Self {
        Self { location, tags: None, sku }
    }
}
#[doc = "Request body to get the availability for scheduling orders."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScheduleAvailabilityRequest {
    #[doc = "Location for data transfer. \r\nFor locations check: https://management.azure.com/subscriptions/SUBSCRIPTIONID/locations?api-version=2018-01-01"]
    #[serde(rename = "storageLocation")]
    pub storage_location: String,
    #[doc = "Sku Name for which the order is to be scheduled."]
    #[serde(rename = "skuName")]
    pub sku_name: schedule_availability_request::SkuName,
}
impl ScheduleAvailabilityRequest {
    pub fn new(storage_location: String, sku_name: schedule_availability_request::SkuName) -> Self {
        Self {
            storage_location,
            sku_name,
        }
    }
}
pub mod schedule_availability_request {
    use super::*;
    #[doc = "Sku Name for which the order is to be scheduled."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum SkuName {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Schedule availability response for given sku in a region."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ScheduleAvailabilityResponse {
    #[doc = "List of dates available to schedule"]
    #[serde(rename = "availableDates", default, skip_serializing_if = "Vec::is_empty")]
    pub available_dates: Vec<String>,
}
impl ScheduleAvailabilityResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Credential details of the shares in account."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ShareCredentialDetails {
    #[doc = "Name of the share."]
    #[serde(rename = "shareName", default, skip_serializing_if = "Option::is_none")]
    pub share_name: Option<String>,
    #[doc = "Type of the share."]
    #[serde(rename = "shareType", default, skip_serializing_if = "Option::is_none")]
    pub share_type: Option<share_credential_details::ShareType>,
    #[doc = "User name for the share."]
    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
    pub user_name: Option<String>,
    #[doc = "Password for the share."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[doc = "Access protocols supported on the device."]
    #[serde(rename = "supportedAccessProtocols", default, skip_serializing_if = "Vec::is_empty")]
    pub supported_access_protocols: Vec<String>,
}
impl ShareCredentialDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod share_credential_details {
    use super::*;
    #[doc = "Type of the share."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ShareType {
        UnknownType,
        #[serde(rename = "HCS")]
        Hcs,
        BlockBlob,
        PageBlob,
        AzureFile,
        ManagedDisk,
    }
}
#[doc = "Shipment pick up request details."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ShipmentPickUpRequest {
    #[doc = "Minimum date after which the pick up should commence, this must be in local time of pick up area."]
    #[serde(rename = "startTime")]
    pub start_time: String,
    #[doc = "Maximum date before which the pick up should commence, this must be in local time of pick up area."]
    #[serde(rename = "endTime")]
    pub end_time: String,
    #[doc = "Shipment Location in the pickup place. Eg.front desk"]
    #[serde(rename = "shipmentLocation")]
    pub shipment_location: String,
}
impl ShipmentPickUpRequest {
    pub fn new(start_time: String, end_time: String, shipment_location: String) -> Self {
        Self {
            start_time,
            end_time,
            shipment_location,
        }
    }
}
#[doc = "Shipment pick up response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ShipmentPickUpResponse {
    #[doc = "Confirmation number for the pick up request."]
    #[serde(rename = "confirmationNumber", default, skip_serializing_if = "Option::is_none")]
    pub confirmation_number: Option<String>,
    #[doc = "Time by which shipment should be ready for pick up, this is in local time of pick up area."]
    #[serde(rename = "readyByTime", default, skip_serializing_if = "Option::is_none")]
    pub ready_by_time: Option<String>,
}
impl ShipmentPickUpResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Shipping address where customer wishes to receive the device."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ShippingAddress {
    #[doc = "Street Address line 1."]
    #[serde(rename = "streetAddress1")]
    pub street_address1: String,
    #[doc = "Street Address line 2."]
    #[serde(rename = "streetAddress2", default, skip_serializing_if = "Option::is_none")]
    pub street_address2: Option<String>,
    #[doc = "Street Address line 3."]
    #[serde(rename = "streetAddress3", default, skip_serializing_if = "Option::is_none")]
    pub street_address3: Option<String>,
    #[doc = "Name of the City."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[doc = "Name of the State or Province."]
    #[serde(rename = "stateOrProvince", default, skip_serializing_if = "Option::is_none")]
    pub state_or_province: Option<String>,
    #[doc = "Name of the Country."]
    pub country: String,
    #[doc = "Postal code."]
    #[serde(rename = "postalCode")]
    pub postal_code: String,
    #[doc = "Extended Zip Code."]
    #[serde(rename = "zipExtendedCode", default, skip_serializing_if = "Option::is_none")]
    pub zip_extended_code: Option<String>,
    #[doc = "Name of the company."]
    #[serde(rename = "companyName", default, skip_serializing_if = "Option::is_none")]
    pub company_name: Option<String>,
    #[doc = "Type of address."]
    #[serde(rename = "addressType", default, skip_serializing_if = "Option::is_none")]
    pub address_type: Option<shipping_address::AddressType>,
}
impl ShippingAddress {
    pub fn new(street_address1: String, country: String, postal_code: String) -> Self {
        Self {
            street_address1,
            street_address2: None,
            street_address3: None,
            city: None,
            state_or_province: None,
            country,
            postal_code,
            zip_extended_code: None,
            company_name: None,
            address_type: None,
        }
    }
}
pub mod shipping_address {
    use super::*;
    #[doc = "Type of address."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum AddressType {
        None,
        Residential,
        Commercial,
    }
    impl Default for AddressType {
        fn default() -> Self {
            Self::None
        }
    }
}
#[doc = "The Sku."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Sku {
    #[doc = "The sku name."]
    pub name: sku::Name,
    #[doc = "The display name of the sku."]
    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    #[doc = "The sku family."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub family: Option<String>,
}
impl Sku {
    pub fn new(name: sku::Name) -> Self {
        Self {
            name,
            display_name: None,
            family: None,
        }
    }
}
pub mod sku {
    use super::*;
    #[doc = "The sku name."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Name {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Request to validate sku availability."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SkuAvailabilityValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[doc = "Device type to be used for the job."]
    #[serde(rename = "deviceType")]
    pub device_type: sku_availability_validation_request::DeviceType,
    #[doc = "Type of the transfer."]
    #[serde(rename = "transferType")]
    pub transfer_type: sku_availability_validation_request::TransferType,
    #[doc = "ISO country code. Country for hardware shipment. For codes check: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2#Officially_assigned_code_elements"]
    pub country: String,
    #[doc = "Location for data transfer. For locations check: https://management.azure.com/subscriptions/SUBSCRIPTIONID/locations?api-version=2018-01-01"]
    pub location: String,
}
impl SkuAvailabilityValidationRequest {
    pub fn new(
        validation_input_request: ValidationInputRequest,
        device_type: sku_availability_validation_request::DeviceType,
        transfer_type: sku_availability_validation_request::TransferType,
        country: String,
        location: String,
    ) -> Self {
        Self {
            validation_input_request,
            device_type,
            transfer_type,
            country,
            location,
        }
    }
}
pub mod sku_availability_validation_request {
    use super::*;
    #[doc = "Device type to be used for the job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
    #[doc = "Type of the transfer."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
    }
}
#[doc = "Properties of sku availability validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SkuAvailabilityValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "Sku availability validation status."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<sku_availability_validation_response_properties::Status>,
}
impl SkuAvailabilityValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod sku_availability_validation_response_properties {
    use super::*;
    #[doc = "Sku availability validation status."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[doc = "Capacity of the sku."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuCapacity {
    #[doc = "Usable capacity in TB."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usable: Option<String>,
    #[doc = "Maximum capacity in TB."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub maximum: Option<String>,
}
impl SkuCapacity {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Describes metadata for retrieving price info."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuCost {
    #[doc = "Meter id of the Sku."]
    #[serde(rename = "meterId", default, skip_serializing_if = "Option::is_none")]
    pub meter_id: Option<String>,
    #[doc = "The type of the meter."]
    #[serde(rename = "meterType", default, skip_serializing_if = "Option::is_none")]
    pub meter_type: Option<String>,
}
impl SkuCost {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Information of the sku."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuInformation {
    #[doc = "The Sku."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sku: Option<Sku>,
    #[doc = "The sku is enabled or not."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[doc = "Properties of the sku."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<SkuProperties>,
}
impl SkuInformation {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Properties of the sku."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuProperties {
    #[doc = "The map of destination location to service location."]
    #[serde(rename = "destinationToServiceLocationMap", default, skip_serializing_if = "Vec::is_empty")]
    pub destination_to_service_location_map: Vec<DestinationToServiceLocationMap>,
    #[doc = "Capacity of the sku."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capacity: Option<SkuCapacity>,
    #[doc = "Cost of the Sku."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub costs: Vec<SkuCost>,
    #[doc = "Api versions that support this Sku."]
    #[serde(rename = "apiVersions", default, skip_serializing_if = "Vec::is_empty")]
    pub api_versions: Vec<String>,
    #[doc = "Reason why the Sku is disabled."]
    #[serde(rename = "disabledReason", default, skip_serializing_if = "Option::is_none")]
    pub disabled_reason: Option<sku_properties::DisabledReason>,
    #[doc = "Message for why the Sku is disabled."]
    #[serde(rename = "disabledReasonMessage", default, skip_serializing_if = "Option::is_none")]
    pub disabled_reason_message: Option<String>,
    #[doc = "Required feature to access the sku."]
    #[serde(rename = "requiredFeature", default, skip_serializing_if = "Option::is_none")]
    pub required_feature: Option<String>,
}
impl SkuProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod sku_properties {
    use super::*;
    #[doc = "Reason why the Sku is disabled."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DisabledReason {
        None,
        Country,
        Region,
        Feature,
        OfferType,
        NoSubscriptionInfo,
    }
}
#[doc = "Request to validate subscription permission to create jobs."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SubscriptionIsAllowedToCreateJobValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
}
impl SubscriptionIsAllowedToCreateJobValidationRequest {
    pub fn new(validation_input_request: ValidationInputRequest) -> Self {
        Self { validation_input_request }
    }
}
#[doc = "Properties of subscription permission to create job validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SubscriptionIsAllowedToCreateJobValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[doc = "Validation status of subscription permission to create job."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<subscription_is_allowed_to_create_job_validation_response_properties::Status>,
}
impl SubscriptionIsAllowedToCreateJobValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod subscription_is_allowed_to_create_job_validation_response_properties {
    use super::*;
    #[doc = "Validation status of subscription permission to create job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[doc = "Transport options availability details for given region."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityDetails {
    #[doc = "Transport Shipment Type supported for given region."]
    #[serde(rename = "shipmentType", default, skip_serializing_if = "Option::is_none")]
    pub shipment_type: Option<transport_availability_details::ShipmentType>,
}
impl TransportAvailabilityDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod transport_availability_details {
    use super::*;
    #[doc = "Transport Shipment Type supported for given region."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ShipmentType {
        CustomerManaged,
        MicrosoftManaged,
    }
}
#[doc = "Request body to get the transport availability for given sku."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityRequest {
    #[doc = "Type of the device."]
    #[serde(rename = "skuName", default, skip_serializing_if = "Option::is_none")]
    pub sku_name: Option<transport_availability_request::SkuName>,
}
impl TransportAvailabilityRequest {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod transport_availability_request {
    use super::*;
    #[doc = "Type of the device."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum SkuName {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Transport options available for given sku in a region."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityResponse {
    #[doc = "List of transport availability details for given region"]
    #[serde(rename = "transportAvailabilityDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub transport_availability_details: Vec<TransportAvailabilityDetails>,
}
impl TransportAvailabilityResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Preferences related to the shipment logistics of the sku"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransportPreferences {
    #[doc = "Indicates Shipment Logistics type that the customer preferred."]
    #[serde(rename = "preferredShipmentType")]
    pub preferred_shipment_type: transport_preferences::PreferredShipmentType,
}
impl TransportPreferences {
    pub fn new(preferred_shipment_type: transport_preferences::PreferredShipmentType) -> Self {
        Self { preferred_shipment_type }
    }
}
pub mod transport_preferences {
    use super::*;
    #[doc = "Indicates Shipment Logistics type that the customer preferred."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum PreferredShipmentType {
        CustomerManaged,
        MicrosoftManaged,
    }
}
#[doc = "Unencrypted credentials for accessing device."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UnencryptedCredentials {
    #[doc = "Name of the job."]
    #[serde(rename = "jobName", default, skip_serializing_if = "Option::is_none")]
    pub job_name: Option<String>,
    #[doc = "The base class for the secrets"]
    #[serde(rename = "jobSecrets", default, skip_serializing_if = "Option::is_none")]
    pub job_secrets: Option<JobSecrets>,
}
impl UnencryptedCredentials {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "List of unencrypted credentials for accessing device."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UnencryptedCredentialsList {
    #[doc = "List of unencrypted credentials."]
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<UnencryptedCredentials>,
    #[doc = "Link for the next set of unencrypted credentials."]
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl UnencryptedCredentialsList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Job details for update."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateJobDetails {
    #[doc = "Contact Details."]
    #[serde(rename = "contactDetails", default, skip_serializing_if = "Option::is_none")]
    pub contact_details: Option<ContactDetails>,
    #[doc = "Shipping address where customer wishes to receive the device."]
    #[serde(rename = "shippingAddress", default, skip_serializing_if = "Option::is_none")]
    pub shipping_address: Option<ShippingAddress>,
}
impl UpdateJobDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Job Properties for update"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateJobProperties {
    #[doc = "Job details for update."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<UpdateJobDetails>,
    #[doc = "Destination account details."]
    #[serde(rename = "destinationAccountDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub destination_account_details: Vec<DestinationAccountDetails>,
}
impl UpdateJobProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "The requirements to validate customer address where the device needs to be shipped."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidateAddress {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[doc = "Shipping address where customer wishes to receive the device."]
    #[serde(rename = "shippingAddress")]
    pub shipping_address: ShippingAddress,
    #[doc = "Device type to be used for the job."]
    #[serde(rename = "deviceType")]
    pub device_type: validate_address::DeviceType,
    #[doc = "Preferences related to the shipment logistics of the sku"]
    #[serde(rename = "transportPreferences", default, skip_serializing_if = "Option::is_none")]
    pub transport_preferences: Option<TransportPreferences>,
}
impl ValidateAddress {
    pub fn new(
        validation_input_request: ValidationInputRequest,
        shipping_address: ShippingAddress,
        device_type: validate_address::DeviceType,
    ) -> Self {
        Self {
            validation_input_request,
            shipping_address,
            device_type,
            transport_preferences: None,
        }
    }
}
pub mod validate_address {
    use super::*;
    #[doc = "Device type to be used for the job."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[doc = "Minimum fields that must be present in any type of validation request."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationInputRequest {
    #[doc = "Identifies the type of validation request."]
    #[serde(rename = "validationType")]
    pub validation_type: validation_input_request::ValidationType,
}
impl ValidationInputRequest {
    pub fn new(validation_type: validation_input_request::ValidationType) -> Self {
        Self { validation_type }
    }
}
pub mod validation_input_request {
    use super::*;
    #[doc = "Identifies the type of validation request."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationType {
        ValidateAddress,
        ValidateDataDestinationDetails,
        ValidateSubscriptionIsAllowedToCreateJob,
        ValidatePreferences,
        ValidateCreateOrderLimit,
        ValidateSkuAvailability,
    }
}
#[doc = "Minimum properties that should be present in each individual validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationInputResponse {
    #[doc = "Identifies the type of validation response."]
    #[serde(rename = "validationType")]
    pub validation_type: validation_input_response::ValidationType,
    #[doc = "Top level error for the job."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<Error>,
}
impl ValidationInputResponse {
    pub fn new(validation_type: validation_input_response::ValidationType) -> Self {
        Self {
            validation_type,
            error: None,
        }
    }
}
pub mod validation_input_response {
    use super::*;
    #[doc = "Identifies the type of validation response."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationType {
        ValidateAddress,
        ValidateDataDestinationDetails,
        ValidateSubscriptionIsAllowedToCreateJob,
        ValidatePreferences,
        ValidateCreateOrderLimit,
        ValidateSkuAvailability,
    }
}
#[doc = "Input request for all pre job creation validation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationRequest {
    #[doc = "List of request details contain validationType and its request as key and value respectively."]
    #[serde(rename = "individualRequestDetails")]
    pub individual_request_details: Vec<ValidationInputRequest>,
    #[doc = "Identify the nature of validation."]
    #[serde(rename = "validationCategory")]
    pub validation_category: validation_request::ValidationCategory,
}
impl ValidationRequest {
    pub fn new(
        individual_request_details: Vec<ValidationInputRequest>,
        validation_category: validation_request::ValidationCategory,
    ) -> Self {
        Self {
            individual_request_details,
            validation_category,
        }
    }
}
pub mod validation_request {
    use super::*;
    #[doc = "Identify the nature of validation."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationCategory {
        JobCreationValidation,
    }
}
#[doc = "Response of pre job creation validations."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ValidationResponse {
    #[doc = "Properties of pre job creation validation response."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<ValidationResponseProperties>,
}
impl ValidationResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[doc = "Properties of pre job creation validation response."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ValidationResponseProperties {
    #[doc = "Overall validation status."]
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<validation_response_properties::Status>,
    #[doc = "List of response details contain validationType and its response as key and value respectively."]
    #[serde(rename = "individualResponseDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub individual_response_details: Vec<ValidationInputResponse>,
}
impl ValidationResponseProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod validation_response_properties {
    use super::*;
    #[doc = "Overall validation status."]
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        AllValidToProceed,
        InputsRevisitRequired,
        CertainInputValidationsSkipped,
    }
}
