#![doc = "generated by AutoRust"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AccountCredentialDetails {
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[serde(rename = "dataAccountType", default, skip_serializing_if = "Option::is_none")]
    pub data_account_type: Option<account_credential_details::DataAccountType>,
    #[serde(rename = "accountConnectionString", default, skip_serializing_if = "Option::is_none")]
    pub account_connection_string: Option<String>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataAccountType {
        StorageAccount,
        ManagedDisk,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AdditionalErrorInfo {
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub info: Option<serde_json::Value>,
}
impl AdditionalErrorInfo {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AddressValidationOutput {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<AddressValidationProperties>,
}
impl AddressValidationOutput {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AddressValidationProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[serde(rename = "validationStatus", default, skip_serializing_if = "Option::is_none")]
    pub validation_status: Option<address_validation_properties::ValidationStatus>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationStatus {
        Valid,
        Invalid,
        Ambiguous,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ApiError {
    pub error: ErrorDetail,
}
impl ApiError {
    pub fn new(error: ErrorDetail) -> Self {
        Self { error }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ApplianceNetworkConfiguration {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "macAddress", default, skip_serializing_if = "Option::is_none")]
    pub mac_address: Option<String>,
}
impl ApplianceNetworkConfiguration {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ArmBaseObject {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
}
impl ArmBaseObject {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct AvailableSkuRequest {
    #[serde(rename = "transferType")]
    pub transfer_type: available_sku_request::TransferType,
    pub country: String,
    pub location: String,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
        ExportFromAzure,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AvailableSkusResult {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<SkuInformation>,
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl AvailableSkusResult {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct AzureFileFilterDetails {
    #[serde(rename = "filePrefixList", default, skip_serializing_if = "Vec::is_empty")]
    pub file_prefix_list: Vec<String>,
    #[serde(rename = "filePathList", default, skip_serializing_if = "Vec::is_empty")]
    pub file_path_list: Vec<String>,
    #[serde(rename = "fileShareList", default, skip_serializing_if = "Vec::is_empty")]
    pub file_share_list: Vec<String>,
}
impl AzureFileFilterDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct BlobFilterDetails {
    #[serde(rename = "blobPrefixList", default, skip_serializing_if = "Vec::is_empty")]
    pub blob_prefix_list: Vec<String>,
    #[serde(rename = "blobPathList", default, skip_serializing_if = "Vec::is_empty")]
    pub blob_path_list: Vec<String>,
    #[serde(rename = "containerList", default, skip_serializing_if = "Vec::is_empty")]
    pub container_list: Vec<String>,
}
impl BlobFilterDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CancellationReason {
    pub reason: String,
}
impl CancellationReason {
    pub fn new(reason: String) -> Self {
        Self { reason }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CloudError {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub details: Vec<CloudError>,
    #[serde(rename = "additionalInfo", default, skip_serializing_if = "Vec::is_empty")]
    pub additional_info: Vec<AdditionalErrorInfo>,
}
impl CloudError {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ContactDetails {
    #[serde(rename = "contactName")]
    pub contact_name: String,
    pub phone: String,
    #[serde(rename = "phoneExtension", default, skip_serializing_if = "Option::is_none")]
    pub phone_extension: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub mobile: Option<String>,
    #[serde(rename = "emailList")]
    pub email_list: Vec<String>,
    #[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(),
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CopyLogDetails {
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum CopyLogDetailsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct CopyProgress {
    #[serde(rename = "storageAccountName", default, skip_serializing_if = "Option::is_none")]
    pub storage_account_name: Option<String>,
    #[serde(rename = "transferType", default, skip_serializing_if = "Option::is_none")]
    pub transfer_type: Option<copy_progress::TransferType>,
    #[serde(rename = "dataAccountType", default, skip_serializing_if = "Option::is_none")]
    pub data_account_type: Option<copy_progress::DataAccountType>,
    #[serde(rename = "accountId", default, skip_serializing_if = "Option::is_none")]
    pub account_id: Option<String>,
    #[serde(rename = "bytesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub bytes_processed: Option<i64>,
    #[serde(rename = "totalBytesToProcess", default, skip_serializing_if = "Option::is_none")]
    pub total_bytes_to_process: Option<i64>,
    #[serde(rename = "filesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub files_processed: Option<i64>,
    #[serde(rename = "totalFilesToProcess", default, skip_serializing_if = "Option::is_none")]
    pub total_files_to_process: Option<i64>,
    #[serde(rename = "invalidFilesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub invalid_files_processed: Option<i64>,
    #[serde(rename = "invalidFileBytesUploaded", default, skip_serializing_if = "Option::is_none")]
    pub invalid_file_bytes_uploaded: Option<i64>,
    #[serde(rename = "renamedContainerCount", default, skip_serializing_if = "Option::is_none")]
    pub renamed_container_count: Option<i64>,
    #[serde(rename = "filesErroredOut", default, skip_serializing_if = "Option::is_none")]
    pub files_errored_out: Option<i64>,
    #[serde(rename = "directoriesErroredOut", default, skip_serializing_if = "Option::is_none")]
    pub directories_errored_out: Option<i64>,
    #[serde(rename = "invalidDirectoriesProcessed", default, skip_serializing_if = "Option::is_none")]
    pub invalid_directories_processed: Option<i64>,
    #[serde(rename = "isEnumerationInProgress", default, skip_serializing_if = "Option::is_none")]
    pub is_enumeration_in_progress: Option<bool>,
}
impl CopyProgress {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod copy_progress {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
        ExportFromAzure,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataAccountType {
        StorageAccount,
        ManagedDisk,
    }
}
#[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 }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateOrderLimitForSubscriptionValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CreateOrderLimitForSubscriptionValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataAccountDetails {
    #[serde(rename = "dataAccountType")]
    pub data_account_type: data_account_details::DataAccountType,
    #[serde(rename = "sharePassword", default, skip_serializing_if = "Option::is_none")]
    pub share_password: Option<String>,
}
impl DataAccountDetails {
    pub fn new(data_account_type: data_account_details::DataAccountType) -> Self {
        Self {
            data_account_type,
            share_password: None,
        }
    }
}
pub mod data_account_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataAccountType {
        StorageAccount,
        ManagedDisk,
    }
    impl Default for DataAccountType {
        fn default() -> Self {
            Self::StorageAccount
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxAccountCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[serde(rename = "copyLogLink", default, skip_serializing_if = "Option::is_none")]
    pub copy_log_link: Option<String>,
    #[serde(rename = "copyVerboseLogLink", default, skip_serializing_if = "Option::is_none")]
    pub copy_verbose_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,
            copy_verbose_log_link: None,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[serde(rename = "diskSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub disk_serial_number: Option<String>,
    #[serde(rename = "errorLogLink", default, skip_serializing_if = "Option::is_none")]
    pub error_log_link: Option<String>,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxDiskCopyProgress {
    #[serde(rename = "serialNumber", default, skip_serializing_if = "Option::is_none")]
    pub serial_number: Option<String>,
    #[serde(rename = "bytesCopied", default, skip_serializing_if = "Option::is_none")]
    pub bytes_copied: Option<i64>,
    #[serde(rename = "percentComplete", default, skip_serializing_if = "Option::is_none")]
    pub percent_complete: Option<i32>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        NotStarted,
        InProgress,
        Completed,
        CompletedWithErrors,
        Failed,
        NotReturned,
        HardwareError,
        DeviceFormatted,
        DeviceMetadataModified,
        StorageAccountNotAccessible,
        UnsupportedData,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[serde(rename = "preferredDisks", default, skip_serializing_if = "Option::is_none")]
    pub preferred_disks: Option<serde_json::Value>,
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<DataBoxDiskCopyProgress>,
    #[serde(rename = "disksAndSizeDetails", default, skip_serializing_if = "Option::is_none")]
    pub disks_and_size_details: Option<serde_json::Value>,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxDiskJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[serde(rename = "diskSecrets", default, skip_serializing_if = "Vec::is_empty")]
    pub disk_secrets: Vec<DiskSecret>,
    #[serde(rename = "passKey", default, skip_serializing_if = "Option::is_none")]
    pub pass_key: Option<String>,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyAccountCopyLogDetails {
    #[serde(flatten)]
    pub copy_log_details: CopyLogDetails,
    #[serde(rename = "accountName", default, skip_serializing_if = "Option::is_none")]
    pub account_name: Option<String>,
    #[serde(rename = "copyLogLink", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_log_link: Vec<String>,
    #[serde(rename = "copyVerboseLogLink", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_verbose_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(),
            copy_verbose_log_link: Vec::new(),
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<CopyProgress>,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxHeavyJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[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(),
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxHeavySecret {
    #[serde(rename = "deviceSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub device_serial_number: Option<String>,
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
    #[serde(rename = "networkConfigurations", default, skip_serializing_if = "Vec::is_empty")]
    pub network_configurations: Vec<ApplianceNetworkConfiguration>,
    #[serde(rename = "encodedValidationCertPubKey", default, skip_serializing_if = "Option::is_none")]
    pub encoded_validation_cert_pub_key: Option<String>,
    #[serde(rename = "accountCredentialDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub account_credential_details: Vec<AccountCredentialDetails>,
}
impl DataBoxHeavySecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataBoxJobDetails {
    #[serde(flatten)]
    pub job_details: JobDetails,
    #[serde(rename = "copyProgress", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_progress: Vec<CopyProgress>,
    #[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,
        }
    }
}
#[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataBoxSecret {
    #[serde(rename = "deviceSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub device_serial_number: Option<String>,
    #[serde(rename = "devicePassword", default, skip_serializing_if = "Option::is_none")]
    pub device_password: Option<String>,
    #[serde(rename = "networkConfigurations", default, skip_serializing_if = "Vec::is_empty")]
    pub network_configurations: Vec<ApplianceNetworkConfiguration>,
    #[serde(rename = "encodedValidationCertPubKey", default, skip_serializing_if = "Option::is_none")]
    pub encoded_validation_cert_pub_key: Option<String>,
    #[serde(rename = "accountCredentialDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub account_credential_details: Vec<AccountCredentialDetails>,
}
impl DataBoxSecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataExportDetails {
    #[serde(rename = "transferConfiguration")]
    pub transfer_configuration: TransferConfiguration,
    #[serde(rename = "logCollectionLevel", default, skip_serializing_if = "Option::is_none")]
    pub log_collection_level: Option<data_export_details::LogCollectionLevel>,
    #[serde(rename = "accountDetails")]
    pub account_details: DataAccountDetails,
}
impl DataExportDetails {
    pub fn new(transfer_configuration: TransferConfiguration, account_details: DataAccountDetails) -> Self {
        Self {
            transfer_configuration,
            log_collection_level: None,
            account_details,
        }
    }
}
pub mod data_export_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum LogCollectionLevel {
        Error,
        Verbose,
    }
    impl Default for LogCollectionLevel {
        fn default() -> Self {
            Self::Error
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataImportDetails {
    #[serde(rename = "accountDetails")]
    pub account_details: DataAccountDetails,
}
impl DataImportDetails {
    pub fn new(account_details: DataAccountDetails) -> Self {
        Self { account_details }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DataLocationToServiceLocationMap {
    #[serde(rename = "dataLocation", default, skip_serializing_if = "Option::is_none")]
    pub data_location: Option<String>,
    #[serde(rename = "serviceLocation", default, skip_serializing_if = "Option::is_none")]
    pub service_location: Option<String>,
}
impl DataLocationToServiceLocationMap {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataTransferDetailsValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[serde(rename = "dataExportDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub data_export_details: Vec<DataExportDetails>,
    #[serde(rename = "dataImportDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub data_import_details: Vec<DataImportDetails>,
    #[serde(rename = "deviceType")]
    pub device_type: data_transfer_details_validation_request::DeviceType,
    #[serde(rename = "transferType")]
    pub transfer_type: data_transfer_details_validation_request::TransferType,
}
impl DataTransferDetailsValidationRequest {
    pub fn new(
        validation_input_request: ValidationInputRequest,
        device_type: data_transfer_details_validation_request::DeviceType,
        transfer_type: data_transfer_details_validation_request::TransferType,
    ) -> Self {
        Self {
            validation_input_request,
            data_export_details: Vec::new(),
            data_import_details: Vec::new(),
            device_type,
            transfer_type,
        }
    }
}
pub mod data_transfer_details_validation_request {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
        ExportFromAzure,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataTransferDetailsValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<data_transfer_details_validation_response_properties::Status>,
}
impl DataTransferDetailsValidationResponseProperties {
    pub fn new(validation_input_response: ValidationInputResponse) -> Self {
        Self {
            validation_input_response,
            status: None,
        }
    }
}
pub mod data_transfer_details_validation_response_properties {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DataboxJobSecrets {
    #[serde(flatten)]
    pub job_secrets: JobSecrets,
    #[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(),
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DcAccessSecurityCode {
    #[serde(rename = "reverseDCAccessCode", default, skip_serializing_if = "Option::is_none")]
    pub reverse_dc_access_code: Option<String>,
    #[serde(rename = "forwardDCAccessCode", default, skip_serializing_if = "Option::is_none")]
    pub forward_dc_access_code: Option<String>,
}
impl DcAccessSecurityCode {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Details {
    pub code: String,
    pub message: String,
}
impl Details {
    pub fn new(code: String, message: String) -> Self {
        Self { code, message }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct DiskScheduleAvailabilityRequest {
    #[serde(flatten)]
    pub schedule_availability_request: ScheduleAvailabilityRequest,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DiskSecret {
    #[serde(rename = "diskSerialNumber", default, skip_serializing_if = "Option::is_none")]
    pub disk_serial_number: Option<String>,
    #[serde(rename = "bitLockerKey", default, skip_serializing_if = "Option::is_none")]
    pub bit_locker_key: Option<String>,
}
impl DiskSecret {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct EncryptionPreferences {
    #[serde(rename = "doubleEncryption", default, skip_serializing_if = "Option::is_none")]
    pub double_encryption: Option<encryption_preferences::DoubleEncryption>,
}
impl EncryptionPreferences {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod encryption_preferences {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DoubleEncryption {
        Enabled,
        Disabled,
    }
    impl Default for DoubleEncryption {
        fn default() -> Self {
            Self::Disabled
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ErrorDetail {
    pub code: String,
    pub message: String,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub details: Vec<Details>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
}
impl ErrorDetail {
    pub fn new(code: String, message: String) -> Self {
        Self {
            code,
            message,
            details: Vec::new(),
            target: None,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct FilterFileDetails {
    #[serde(rename = "filterFileType")]
    pub filter_file_type: filter_file_details::FilterFileType,
    #[serde(rename = "filterFilePath")]
    pub filter_file_path: String,
}
impl FilterFileDetails {
    pub fn new(filter_file_type: filter_file_details::FilterFileType, filter_file_path: String) -> Self {
        Self {
            filter_file_type,
            filter_file_path,
        }
    }
}
pub mod filter_file_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum FilterFileType {
        AzureBlob,
        AzureFile,
    }
}
#[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IdentityProperties {
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    #[serde(rename = "userAssigned", default, skip_serializing_if = "Option::is_none")]
    pub user_assigned: Option<UserAssignedProperties>,
}
impl IdentityProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobDeliveryInfo {
    #[serde(rename = "scheduledDateTime", default, skip_serializing_if = "Option::is_none")]
    pub scheduled_date_time: Option<String>,
}
impl JobDeliveryInfo {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobDetails {
    #[serde(rename = "jobStages", default, skip_serializing_if = "Vec::is_empty")]
    pub job_stages: Vec<JobStages>,
    #[serde(rename = "contactDetails")]
    pub contact_details: ContactDetails,
    #[serde(rename = "shippingAddress", default, skip_serializing_if = "Option::is_none")]
    pub shipping_address: Option<ShippingAddress>,
    #[serde(rename = "deliveryPackage", default, skip_serializing_if = "Option::is_none")]
    pub delivery_package: Option<PackageShippingDetails>,
    #[serde(rename = "returnPackage", default, skip_serializing_if = "Option::is_none")]
    pub return_package: Option<PackageShippingDetails>,
    #[serde(rename = "dataImportDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub data_import_details: Vec<DataImportDetails>,
    #[serde(rename = "dataExportDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub data_export_details: Vec<DataExportDetails>,
    #[serde(rename = "jobDetailsType")]
    pub job_details_type: job_details::JobDetailsType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preferences: Option<Preferences>,
    #[serde(rename = "copyLogDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub copy_log_details: Vec<CopyLogDetails>,
    #[serde(rename = "reverseShipmentLabelSasKey", default, skip_serializing_if = "Option::is_none")]
    pub reverse_shipment_label_sas_key: Option<String>,
    #[serde(rename = "chainOfCustodySasKey", default, skip_serializing_if = "Option::is_none")]
    pub chain_of_custody_sas_key: Option<String>,
    #[serde(rename = "keyEncryptionKey", default, skip_serializing_if = "Option::is_none")]
    pub key_encryption_key: Option<KeyEncryptionKey>,
    #[serde(rename = "expectedDataSizeInTeraBytes", default, skip_serializing_if = "Option::is_none")]
    pub expected_data_size_in_tera_bytes: Option<i32>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub actions: Vec<String>,
    #[serde(rename = "lastMitigationActionOnJob", default, skip_serializing_if = "Option::is_none")]
    pub last_mitigation_action_on_job: Option<LastMitigationActionOnJob>,
}
impl JobDetails {
    pub fn new(contact_details: ContactDetails, job_details_type: job_details::JobDetailsType) -> Self {
        Self {
            job_stages: Vec::new(),
            contact_details,
            shipping_address: None,
            delivery_package: None,
            return_package: None,
            data_import_details: Vec::new(),
            data_export_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,
            key_encryption_key: None,
            expected_data_size_in_tera_bytes: None,
            actions: Vec::new(),
            last_mitigation_action_on_job: None,
        }
    }
}
pub mod job_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum JobDetailsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobProperties {
    #[serde(rename = "transferType")]
    pub transfer_type: job_properties::TransferType,
    #[serde(rename = "isCancellable", default, skip_serializing_if = "Option::is_none")]
    pub is_cancellable: Option<bool>,
    #[serde(rename = "isDeletable", default, skip_serializing_if = "Option::is_none")]
    pub is_deletable: Option<bool>,
    #[serde(rename = "isShippingAddressEditable", default, skip_serializing_if = "Option::is_none")]
    pub is_shipping_address_editable: Option<bool>,
    #[serde(rename = "isPrepareToShipEnabled", default, skip_serializing_if = "Option::is_none")]
    pub is_prepare_to_ship_enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<job_properties::Status>,
    #[serde(rename = "startTime", default, skip_serializing_if = "Option::is_none")]
    pub start_time: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<CloudError>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<JobDetails>,
    #[serde(rename = "cancellationReason", default, skip_serializing_if = "Option::is_none")]
    pub cancellation_reason: Option<String>,
    #[serde(rename = "deliveryType", default, skip_serializing_if = "Option::is_none")]
    pub delivery_type: Option<job_properties::DeliveryType>,
    #[serde(rename = "deliveryInfo", default, skip_serializing_if = "Option::is_none")]
    pub delivery_info: Option<JobDeliveryInfo>,
    #[serde(rename = "isCancellableWithoutFee", default, skip_serializing_if = "Option::is_none")]
    pub is_cancellable_without_fee: Option<bool>,
}
impl JobProperties {
    pub fn new(transfer_type: job_properties::TransferType) -> Self {
        Self {
            transfer_type,
            is_cancellable: None,
            is_deletable: None,
            is_shipping_address_editable: None,
            is_prepare_to_ship_enabled: None,
            status: None,
            start_time: None,
            error: None,
            details: None,
            cancellation_reason: None,
            delivery_type: None,
            delivery_info: None,
            is_cancellable_without_fee: None,
        }
    }
}
pub mod job_properties {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
        ExportFromAzure,
    }
    #[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,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeliveryType {
        NonScheduled,
        Scheduled,
    }
    impl Default for DeliveryType {
        fn default() -> Self {
            Self::NonScheduled
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobResource {
    #[serde(flatten)]
    pub resource: Resource,
    pub properties: JobProperties,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    #[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
    pub system_data: Option<SystemData>,
}
impl JobResource {
    pub fn new(resource: Resource, properties: JobProperties) -> Self {
        Self {
            resource,
            properties,
            name: None,
            id: None,
            type_: None,
            system_data: None,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobResourceList {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<JobResource>,
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl JobResourceList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobResourceUpdateParameter {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<UpdateJobProperties>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<serde_json::Value>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub identity: Option<ResourceIdentity>,
}
impl JobResourceUpdateParameter {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct JobSecrets {
    #[serde(rename = "jobSecretsType")]
    pub job_secrets_type: job_secrets::JobSecretsType,
    #[serde(rename = "dcAccessSecurityCode", default, skip_serializing_if = "Option::is_none")]
    pub dc_access_security_code: Option<DcAccessSecurityCode>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<CloudError>,
}
impl JobSecrets {
    pub fn new(job_secrets_type: job_secrets::JobSecretsType) -> Self {
        Self {
            job_secrets_type,
            dc_access_security_code: None,
            error: None,
        }
    }
}
pub mod job_secrets {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum JobSecretsType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct JobStages {
    #[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
    pub stage_name: Option<job_stages::StageName>,
    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    #[serde(rename = "stageStatus", default, skip_serializing_if = "Option::is_none")]
    pub stage_status: Option<job_stages::StageStatus>,
    #[serde(rename = "stageTime", default, skip_serializing_if = "Option::is_none")]
    pub stage_time: Option<String>,
    #[serde(rename = "jobStageDetails", default, skip_serializing_if = "Option::is_none")]
    pub job_stage_details: Option<serde_json::Value>,
}
impl JobStages {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod job_stages {
    use super::*;
    #[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,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum StageStatus {
        None,
        InProgress,
        Succeeded,
        Failed,
        Cancelled,
        Cancelling,
        SucceededWithErrors,
        WaitingForCustomerAction,
        SucceededWithWarnings,
        WaitingForCustomerActionForKek,
        WaitingForCustomerActionForCleanUp,
        CustomerActionPerformedForCleanUp,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct KeyEncryptionKey {
    #[serde(rename = "kekType")]
    pub kek_type: key_encryption_key::KekType,
    #[serde(rename = "identityProperties", default, skip_serializing_if = "Option::is_none")]
    pub identity_properties: Option<IdentityProperties>,
    #[serde(rename = "kekUrl", default, skip_serializing_if = "Option::is_none")]
    pub kek_url: Option<String>,
    #[serde(rename = "kekVaultResourceID", default, skip_serializing_if = "Option::is_none")]
    pub kek_vault_resource_id: Option<String>,
}
impl KeyEncryptionKey {
    pub fn new(kek_type: key_encryption_key::KekType) -> Self {
        Self {
            kek_type,
            identity_properties: None,
            kek_url: None,
            kek_vault_resource_id: None,
        }
    }
}
pub mod key_encryption_key {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum KekType {
        MicrosoftManaged,
        CustomerManaged,
    }
    impl Default for KekType {
        fn default() -> Self {
            Self::MicrosoftManaged
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct LastMitigationActionOnJob {
    #[serde(rename = "actionDateTimeInUtc", default, skip_serializing_if = "Option::is_none")]
    pub action_date_time_in_utc: Option<String>,
    #[serde(rename = "isPerformedByCustomer", default, skip_serializing_if = "Option::is_none")]
    pub is_performed_by_customer: Option<bool>,
    #[serde(rename = "customerResolution", default, skip_serializing_if = "Option::is_none")]
    pub customer_resolution: Option<last_mitigation_action_on_job::CustomerResolution>,
}
impl LastMitigationActionOnJob {
    pub fn new() -> Self {
        Self::default()
    }
}
pub mod last_mitigation_action_on_job {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum CustomerResolution {
        None,
        MoveToCleanUpDevice,
        Resume,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ManagedDiskDetails {
    #[serde(flatten)]
    pub data_account_details: DataAccountDetails,
    #[serde(rename = "resourceGroupId")]
    pub resource_group_id: String,
    #[serde(rename = "stagingStorageAccountId")]
    pub staging_storage_account_id: String,
}
impl ManagedDiskDetails {
    pub fn new(data_account_details: DataAccountDetails, resource_group_id: String, staging_storage_account_id: String) -> Self {
        Self {
            data_account_details,
            resource_group_id,
            staging_storage_account_id,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct MitigateJobRequest {
    #[serde(rename = "customerResolutionCode")]
    pub customer_resolution_code: mitigate_job_request::CustomerResolutionCode,
}
impl MitigateJobRequest {
    pub fn new(customer_resolution_code: mitigate_job_request::CustomerResolutionCode) -> Self {
        Self { customer_resolution_code }
    }
}
pub mod mitigate_job_request {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum CustomerResolutionCode {
        None,
        MoveToCleanUpDevice,
        Resume,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct NotificationPreference {
    #[serde(rename = "stageName")]
    pub stage_name: notification_preference::StageName,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum StageName {
        DevicePrepared,
        Dispatched,
        Delivered,
        PickedUp,
        #[serde(rename = "AtAzureDC")]
        AtAzureDc,
        DataCopy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Operation {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub display: Option<OperationDisplay>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<OperationProperties>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub origin: Option<String>,
    #[serde(rename = "isDataAction", default, skip_serializing_if = "Option::is_none")]
    pub is_data_action: Option<bool>,
}
impl Operation {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationDisplay {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub resource: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub operation: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}
impl OperationDisplay {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationList {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<Operation>,
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl OperationList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationProperties {}
impl OperationProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PackageShippingDetails {
    #[serde(rename = "carrierName", default, skip_serializing_if = "Option::is_none")]
    pub carrier_name: Option<String>,
    #[serde(rename = "trackingId", default, skip_serializing_if = "Option::is_none")]
    pub tracking_id: Option<String>,
    #[serde(rename = "trackingUrl", default, skip_serializing_if = "Option::is_none")]
    pub tracking_url: Option<String>,
}
impl PackageShippingDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Preferences {
    #[serde(rename = "preferredDataCenterRegion", default, skip_serializing_if = "Vec::is_empty")]
    pub preferred_data_center_region: Vec<String>,
    #[serde(rename = "transportPreferences", default, skip_serializing_if = "Option::is_none")]
    pub transport_preferences: Option<TransportPreferences>,
    #[serde(rename = "encryptionPreferences", default, skip_serializing_if = "Option::is_none")]
    pub encryption_preferences: Option<EncryptionPreferences>,
}
impl Preferences {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreferencesValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub preference: Option<Preferences>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PreferencesValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RegionConfigurationRequest {
    #[serde(rename = "scheduleAvailabilityRequest", default, skip_serializing_if = "Option::is_none")]
    pub schedule_availability_request: Option<ScheduleAvailabilityRequest>,
    #[serde(rename = "transportAvailabilityRequest", default, skip_serializing_if = "Option::is_none")]
    pub transport_availability_request: Option<TransportAvailabilityRequest>,
}
impl RegionConfigurationRequest {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct RegionConfigurationResponse {
    #[serde(rename = "scheduleAvailabilityResponse", default, skip_serializing_if = "Option::is_none")]
    pub schedule_availability_response: Option<ScheduleAvailabilityResponse>,
    #[serde(rename = "transportAvailabilityResponse", default, skip_serializing_if = "Option::is_none")]
    pub transport_availability_response: Option<TransportAvailabilityResponse>,
}
impl RegionConfigurationResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource {
    pub location: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tags: Option<serde_json::Value>,
    pub sku: Sku,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub identity: Option<ResourceIdentity>,
}
impl Resource {
    pub fn new(location: String, sku: Sku) -> Self {
        Self {
            location,
            tags: None,
            sku,
            identity: None,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ResourceIdentity {
    #[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
    pub type_: Option<String>,
    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
    pub principal_id: Option<String>,
    #[serde(rename = "tenantId", default, skip_serializing_if = "Option::is_none")]
    pub tenant_id: Option<String>,
    #[serde(rename = "userAssignedIdentities", default, skip_serializing_if = "Option::is_none")]
    pub user_assigned_identities: Option<serde_json::Value>,
}
impl ResourceIdentity {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ScheduleAvailabilityRequest {
    #[serde(rename = "storageLocation")]
    pub storage_location: String,
    #[serde(rename = "skuName")]
    pub sku_name: schedule_availability_request::SkuName,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
}
impl ScheduleAvailabilityRequest {
    pub fn new(storage_location: String, sku_name: schedule_availability_request::SkuName) -> Self {
        Self {
            storage_location,
            sku_name,
            country: None,
        }
    }
}
pub mod schedule_availability_request {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum SkuName {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ScheduleAvailabilityResponse {
    #[serde(rename = "availableDates", default, skip_serializing_if = "Vec::is_empty")]
    pub available_dates: Vec<String>,
}
impl ScheduleAvailabilityResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ShareCredentialDetails {
    #[serde(rename = "shareName", default, skip_serializing_if = "Option::is_none")]
    pub share_name: Option<String>,
    #[serde(rename = "shareType", default, skip_serializing_if = "Option::is_none")]
    pub share_type: Option<share_credential_details::ShareType>,
    #[serde(rename = "userName", default, skip_serializing_if = "Option::is_none")]
    pub user_name: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ShareType {
        UnknownType,
        #[serde(rename = "HCS")]
        Hcs,
        BlockBlob,
        PageBlob,
        AzureFile,
        ManagedDisk,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ShipmentPickUpRequest {
    #[serde(rename = "startTime")]
    pub start_time: String,
    #[serde(rename = "endTime")]
    pub end_time: String,
    #[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,
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ShipmentPickUpResponse {
    #[serde(rename = "confirmationNumber", default, skip_serializing_if = "Option::is_none")]
    pub confirmation_number: Option<String>,
    #[serde(rename = "readyByTime", default, skip_serializing_if = "Option::is_none")]
    pub ready_by_time: Option<String>,
}
impl ShipmentPickUpResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ShippingAddress {
    #[serde(rename = "streetAddress1")]
    pub street_address1: String,
    #[serde(rename = "streetAddress2", default, skip_serializing_if = "Option::is_none")]
    pub street_address2: Option<String>,
    #[serde(rename = "streetAddress3", default, skip_serializing_if = "Option::is_none")]
    pub street_address3: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(rename = "stateOrProvince", default, skip_serializing_if = "Option::is_none")]
    pub state_or_province: Option<String>,
    pub country: String,
    #[serde(rename = "postalCode", default, skip_serializing_if = "Option::is_none")]
    pub postal_code: Option<String>,
    #[serde(rename = "zipExtendedCode", default, skip_serializing_if = "Option::is_none")]
    pub zip_extended_code: Option<String>,
    #[serde(rename = "companyName", default, skip_serializing_if = "Option::is_none")]
    pub company_name: Option<String>,
    #[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) -> Self {
        Self {
            street_address1,
            street_address2: None,
            street_address3: None,
            city: None,
            state_or_province: None,
            country,
            postal_code: None,
            zip_extended_code: None,
            company_name: None,
            address_type: None,
        }
    }
}
pub mod shipping_address {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum AddressType {
        None,
        Residential,
        Commercial,
    }
    impl Default for AddressType {
        fn default() -> Self {
            Self::None
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Sku {
    pub name: sku::Name,
    #[serde(rename = "displayName", default, skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Name {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SkuAvailabilityValidationRequest {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[serde(rename = "deviceType")]
    pub device_type: sku_availability_validation_request::DeviceType,
    #[serde(rename = "transferType")]
    pub transfer_type: sku_availability_validation_request::TransferType,
    pub country: String,
    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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferType {
        ImportToAzure,
        ExportFromAzure,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SkuAvailabilityValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuCapacity {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub usable: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub maximum: Option<String>,
}
impl SkuCapacity {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuCost {
    #[serde(rename = "meterId", default, skip_serializing_if = "Option::is_none")]
    pub meter_id: Option<String>,
    #[serde(rename = "meterType", default, skip_serializing_if = "Option::is_none")]
    pub meter_type: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub multiplier: Option<f64>,
}
impl SkuCost {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuInformation {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sku: Option<Sku>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub enabled: Option<bool>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<SkuProperties>,
}
impl SkuInformation {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SkuProperties {
    #[serde(rename = "dataLocationToServiceLocationMap", default, skip_serializing_if = "Vec::is_empty")]
    pub data_location_to_service_location_map: Vec<DataLocationToServiceLocationMap>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub capacity: Option<SkuCapacity>,
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub costs: Vec<SkuCost>,
    #[serde(rename = "apiVersions", default, skip_serializing_if = "Vec::is_empty")]
    pub api_versions: Vec<String>,
    #[serde(rename = "disabledReason", default, skip_serializing_if = "Option::is_none")]
    pub disabled_reason: Option<sku_properties::DisabledReason>,
    #[serde(rename = "disabledReasonMessage", default, skip_serializing_if = "Option::is_none")]
    pub disabled_reason_message: Option<String>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DisabledReason {
        None,
        Country,
        Region,
        Feature,
        OfferType,
        NoSubscriptionInfo,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StorageAccountDetails {
    #[serde(flatten)]
    pub data_account_details: DataAccountDetails,
    #[serde(rename = "storageAccountId")]
    pub storage_account_id: String,
}
impl StorageAccountDetails {
    pub fn new(data_account_details: DataAccountDetails, storage_account_id: String) -> Self {
        Self {
            data_account_details,
            storage_account_id,
        }
    }
}
#[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 }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct SubscriptionIsAllowedToCreateJobValidationResponseProperties {
    #[serde(flatten)]
    pub validation_input_response: ValidationInputResponse,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        Valid,
        Invalid,
        Skipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransferAllDetails {
    #[serde(rename = "dataAccountType")]
    pub data_account_type: transfer_all_details::DataAccountType,
    #[serde(rename = "transferAllBlobs", default, skip_serializing_if = "Option::is_none")]
    pub transfer_all_blobs: Option<bool>,
    #[serde(rename = "transferAllFiles", default, skip_serializing_if = "Option::is_none")]
    pub transfer_all_files: Option<bool>,
}
impl TransferAllDetails {
    pub fn new(data_account_type: transfer_all_details::DataAccountType) -> Self {
        Self {
            data_account_type,
            transfer_all_blobs: None,
            transfer_all_files: None,
        }
    }
}
pub mod transfer_all_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataAccountType {
        StorageAccount,
        ManagedDisk,
    }
    impl Default for DataAccountType {
        fn default() -> Self {
            Self::StorageAccount
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransferConfiguration {
    #[serde(rename = "transferConfigurationType")]
    pub transfer_configuration_type: transfer_configuration::TransferConfigurationType,
    #[serde(rename = "transferFilterDetails", default, skip_serializing_if = "Option::is_none")]
    pub transfer_filter_details: Option<transfer_configuration::TransferFilterDetails>,
    #[serde(rename = "transferAllDetails", default, skip_serializing_if = "Option::is_none")]
    pub transfer_all_details: Option<transfer_configuration::TransferAllDetails>,
}
impl TransferConfiguration {
    pub fn new(transfer_configuration_type: transfer_configuration::TransferConfigurationType) -> Self {
        Self {
            transfer_configuration_type,
            transfer_filter_details: None,
            transfer_all_details: None,
        }
    }
}
pub mod transfer_configuration {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum TransferConfigurationType {
        TransferAll,
        TransferUsingFilter,
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
    pub struct TransferFilterDetails {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        pub include: Box<Option<TransferFilterDetails>>,
    }
    impl TransferFilterDetails {
        pub fn new() -> Self {
            Self::default()
        }
    }
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
    pub struct TransferAllDetails {
        #[serde(default, skip_serializing_if = "Option::is_none")]
        pub include: Box<Option<TransferAllDetails>>,
    }
    impl TransferAllDetails {
        pub fn new() -> Self {
            Self::default()
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransferFilterDetails {
    #[serde(rename = "dataAccountType")]
    pub data_account_type: transfer_filter_details::DataAccountType,
    #[serde(rename = "blobFilterDetails", default, skip_serializing_if = "Option::is_none")]
    pub blob_filter_details: Option<BlobFilterDetails>,
    #[serde(rename = "azureFileFilterDetails", default, skip_serializing_if = "Option::is_none")]
    pub azure_file_filter_details: Option<AzureFileFilterDetails>,
    #[serde(rename = "filterFileDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub filter_file_details: Vec<FilterFileDetails>,
}
impl TransferFilterDetails {
    pub fn new(data_account_type: transfer_filter_details::DataAccountType) -> Self {
        Self {
            data_account_type,
            blob_filter_details: None,
            azure_file_filter_details: None,
            filter_file_details: Vec::new(),
        }
    }
}
pub mod transfer_filter_details {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DataAccountType {
        StorageAccount,
        ManagedDisk,
    }
    impl Default for DataAccountType {
        fn default() -> Self {
            Self::StorageAccount
        }
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityDetails {
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ShipmentType {
        CustomerManaged,
        MicrosoftManaged,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityRequest {
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum SkuName {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TransportAvailabilityResponse {
    #[serde(rename = "transportAvailabilityDetails", default, skip_serializing_if = "Vec::is_empty")]
    pub transport_availability_details: Vec<TransportAvailabilityDetails>,
}
impl TransportAvailabilityResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TransportPreferences {
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum PreferredShipmentType {
        CustomerManaged,
        MicrosoftManaged,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UnencryptedCredentials {
    #[serde(rename = "jobName", default, skip_serializing_if = "Option::is_none")]
    pub job_name: Option<String>,
    #[serde(rename = "jobSecrets", default, skip_serializing_if = "Option::is_none")]
    pub job_secrets: Option<JobSecrets>,
}
impl UnencryptedCredentials {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UnencryptedCredentialsList {
    #[serde(default, skip_serializing_if = "Vec::is_empty")]
    pub value: Vec<UnencryptedCredentials>,
    #[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
    pub next_link: Option<String>,
}
impl UnencryptedCredentialsList {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateJobDetails {
    #[serde(rename = "contactDetails", default, skip_serializing_if = "Option::is_none")]
    pub contact_details: Option<ContactDetails>,
    #[serde(rename = "shippingAddress", default, skip_serializing_if = "Option::is_none")]
    pub shipping_address: Option<ShippingAddress>,
    #[serde(rename = "keyEncryptionKey", default, skip_serializing_if = "Option::is_none")]
    pub key_encryption_key: Option<KeyEncryptionKey>,
}
impl UpdateJobDetails {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UpdateJobProperties {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub details: Option<UpdateJobDetails>,
}
impl UpdateJobProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UserAssignedIdentity {
    #[serde(rename = "principalId", default, skip_serializing_if = "Option::is_none")]
    pub principal_id: Option<String>,
    #[serde(rename = "clientId", default, skip_serializing_if = "Option::is_none")]
    pub client_id: Option<String>,
}
impl UserAssignedIdentity {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct UserAssignedProperties {
    #[serde(rename = "resourceId", default, skip_serializing_if = "Option::is_none")]
    pub resource_id: Option<String>,
}
impl UserAssignedProperties {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidateAddress {
    #[serde(flatten)]
    pub validation_input_request: ValidationInputRequest,
    #[serde(rename = "shippingAddress")]
    pub shipping_address: ShippingAddress,
    #[serde(rename = "deviceType")]
    pub device_type: validate_address::DeviceType,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum DeviceType {
        DataBox,
        DataBoxDisk,
        DataBoxHeavy,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationInputRequest {
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationType {
        ValidateAddress,
        ValidateSubscriptionIsAllowedToCreateJob,
        ValidatePreferences,
        ValidateCreateOrderLimit,
        ValidateSkuAvailability,
        ValidateDataTransferDetails,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationInputResponse {
    #[serde(rename = "validationType")]
    pub validation_type: validation_input_response::ValidationType,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub error: Option<CloudError>,
}
impl ValidationInputResponse {
    pub fn new(validation_type: validation_input_response::ValidationType) -> Self {
        Self {
            validation_type,
            error: None,
        }
    }
}
pub mod validation_input_response {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationType {
        ValidateAddress,
        ValidateSubscriptionIsAllowedToCreateJob,
        ValidatePreferences,
        ValidateCreateOrderLimit,
        ValidateSkuAvailability,
        ValidateDataTransferDetails,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ValidationRequest {
    #[serde(rename = "validationCategory")]
    pub validation_category: validation_request::ValidationCategory,
    #[serde(rename = "individualRequestDetails")]
    pub individual_request_details: Vec<ValidationInputRequest>,
}
impl ValidationRequest {
    pub fn new(
        validation_category: validation_request::ValidationCategory,
        individual_request_details: Vec<ValidationInputRequest>,
    ) -> Self {
        Self {
            validation_category,
            individual_request_details,
        }
    }
}
pub mod validation_request {
    use super::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum ValidationCategory {
        JobCreationValidation,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ValidationResponse {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub properties: Option<ValidationResponseProperties>,
}
impl ValidationResponse {
    pub fn new() -> Self {
        Self::default()
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ValidationResponseProperties {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub status: Option<validation_response_properties::Status>,
    #[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::*;
    #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
    pub enum Status {
        AllValidToProceed,
        InputsRevisitRequired,
        CertainInputValidationsSkipped,
    }
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SystemData {
    #[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
    pub created_by: Option<String>,
    #[serde(rename = "createdByType", default, skip_serializing_if = "Option::is_none")]
    pub created_by_type: Option<String>,
    #[serde(rename = "createdAt", default, skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "lastModifiedBy", default, skip_serializing_if = "Option::is_none")]
    pub last_modified_by: Option<String>,
    #[serde(rename = "lastModifiedByType", default, skip_serializing_if = "Option::is_none")]
    pub last_modified_by_type: Option<String>,
    #[serde(rename = "lastModifiedAt", default, skip_serializing_if = "Option::is_none")]
    pub last_modified_at: Option<String>,
}
impl SystemData {
    pub fn new() -> Self {
        Self::default()
    }
}
