aws-sdk-migrationhub 0.24.0

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// <p>Attribute associated with a resource.</p>
/// <p>Note the corresponding format required per type listed below:</p>
/// <dl>
/// <dt>
/// IPV4
/// </dt>
/// <dd>
/// <p> <code>x.x.x.x</code> </p>
/// <p> <i>where x is an integer in the range [0,255]</i> </p>
/// </dd>
/// <dt>
/// IPV6
/// </dt>
/// <dd>
/// <p> <code>y : y : y : y : y : y : y : y</code> </p>
/// <p> <i>where y is a hexadecimal between 0 and FFFF. [0, FFFF]</i> </p>
/// </dd>
/// <dt>
/// MAC_ADDRESS
/// </dt>
/// <dd>
/// <p> <code>^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$</code> </p>
/// </dd>
/// <dt>
/// FQDN
/// </dt>
/// <dd>
/// <p> <code>^[^&lt;&gt;{}\\\\/?,=\\p{Cntrl}]{1,256}$</code> </p>
/// </dd>
/// </dl>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ResourceAttribute {
    /// <p>Type of resource.</p>
    #[doc(hidden)]
    pub r#type: std::option::Option<crate::model::ResourceAttributeType>,
    /// <p>Value of the resource type.</p>
    #[doc(hidden)]
    pub value: std::option::Option<std::string::String>,
}
impl ResourceAttribute {
    /// <p>Type of resource.</p>
    pub fn r#type(&self) -> std::option::Option<&crate::model::ResourceAttributeType> {
        self.r#type.as_ref()
    }
    /// <p>Value of the resource type.</p>
    pub fn value(&self) -> std::option::Option<&str> {
        self.value.as_deref()
    }
}
/// See [`ResourceAttribute`](crate::model::ResourceAttribute).
pub mod resource_attribute {

    /// A builder for [`ResourceAttribute`](crate::model::ResourceAttribute).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) r#type: std::option::Option<crate::model::ResourceAttributeType>,
        pub(crate) value: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Type of resource.</p>
        pub fn r#type(mut self, input: crate::model::ResourceAttributeType) -> Self {
            self.r#type = Some(input);
            self
        }
        /// <p>Type of resource.</p>
        pub fn set_type(
            mut self,
            input: std::option::Option<crate::model::ResourceAttributeType>,
        ) -> Self {
            self.r#type = input;
            self
        }
        /// <p>Value of the resource type.</p>
        pub fn value(mut self, input: impl Into<std::string::String>) -> Self {
            self.value = Some(input.into());
            self
        }
        /// <p>Value of the resource type.</p>
        pub fn set_value(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.value = input;
            self
        }
        /// Consumes the builder and constructs a [`ResourceAttribute`](crate::model::ResourceAttribute).
        pub fn build(self) -> crate::model::ResourceAttribute {
            crate::model::ResourceAttribute {
                r#type: self.r#type,
                value: self.value,
            }
        }
    }
}
impl ResourceAttribute {
    /// Creates a new builder-style object to manufacture [`ResourceAttribute`](crate::model::ResourceAttribute).
    pub fn builder() -> crate::model::resource_attribute::Builder {
        crate::model::resource_attribute::Builder::default()
    }
}

/// When writing a match expression against `ResourceAttributeType`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let resourceattributetype = unimplemented!();
/// match resourceattributetype {
///     ResourceAttributeType::BiosId => { /* ... */ },
///     ResourceAttributeType::Fqdn => { /* ... */ },
///     ResourceAttributeType::Ipv4Address => { /* ... */ },
///     ResourceAttributeType::Ipv6Address => { /* ... */ },
///     ResourceAttributeType::MacAddress => { /* ... */ },
///     ResourceAttributeType::MotherboardSerialNumber => { /* ... */ },
///     ResourceAttributeType::VmManagedObjectReference => { /* ... */ },
///     ResourceAttributeType::VmManagerId => { /* ... */ },
///     ResourceAttributeType::VmName => { /* ... */ },
///     ResourceAttributeType::VmPath => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `resourceattributetype` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ResourceAttributeType::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ResourceAttributeType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `ResourceAttributeType::NewFeature` is defined.
/// Specifically, when `resourceattributetype` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ResourceAttributeType::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum ResourceAttributeType {
    #[allow(missing_docs)] // documentation missing in model
    BiosId,
    #[allow(missing_docs)] // documentation missing in model
    Fqdn,
    #[allow(missing_docs)] // documentation missing in model
    Ipv4Address,
    #[allow(missing_docs)] // documentation missing in model
    Ipv6Address,
    #[allow(missing_docs)] // documentation missing in model
    MacAddress,
    #[allow(missing_docs)] // documentation missing in model
    MotherboardSerialNumber,
    #[allow(missing_docs)] // documentation missing in model
    VmManagedObjectReference,
    #[allow(missing_docs)] // documentation missing in model
    VmManagerId,
    #[allow(missing_docs)] // documentation missing in model
    VmName,
    #[allow(missing_docs)] // documentation missing in model
    VmPath,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ResourceAttributeType {
    fn from(s: &str) -> Self {
        match s {
            "BIOS_ID" => ResourceAttributeType::BiosId,
            "FQDN" => ResourceAttributeType::Fqdn,
            "IPV4_ADDRESS" => ResourceAttributeType::Ipv4Address,
            "IPV6_ADDRESS" => ResourceAttributeType::Ipv6Address,
            "MAC_ADDRESS" => ResourceAttributeType::MacAddress,
            "MOTHERBOARD_SERIAL_NUMBER" => ResourceAttributeType::MotherboardSerialNumber,
            "VM_MANAGED_OBJECT_REFERENCE" => ResourceAttributeType::VmManagedObjectReference,
            "VM_MANAGER_ID" => ResourceAttributeType::VmManagerId,
            "VM_NAME" => ResourceAttributeType::VmName,
            "VM_PATH" => ResourceAttributeType::VmPath,
            other => {
                ResourceAttributeType::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for ResourceAttributeType {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ResourceAttributeType::from(s))
    }
}
impl ResourceAttributeType {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ResourceAttributeType::BiosId => "BIOS_ID",
            ResourceAttributeType::Fqdn => "FQDN",
            ResourceAttributeType::Ipv4Address => "IPV4_ADDRESS",
            ResourceAttributeType::Ipv6Address => "IPV6_ADDRESS",
            ResourceAttributeType::MacAddress => "MAC_ADDRESS",
            ResourceAttributeType::MotherboardSerialNumber => "MOTHERBOARD_SERIAL_NUMBER",
            ResourceAttributeType::VmManagedObjectReference => "VM_MANAGED_OBJECT_REFERENCE",
            ResourceAttributeType::VmManagerId => "VM_MANAGER_ID",
            ResourceAttributeType::VmName => "VM_NAME",
            ResourceAttributeType::VmPath => "VM_PATH",
            ResourceAttributeType::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` values of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &[
            "BIOS_ID",
            "FQDN",
            "IPV4_ADDRESS",
            "IPV6_ADDRESS",
            "MAC_ADDRESS",
            "MOTHERBOARD_SERIAL_NUMBER",
            "VM_MANAGED_OBJECT_REFERENCE",
            "VM_MANAGER_ID",
            "VM_NAME",
            "VM_PATH",
        ]
    }
}
impl AsRef<str> for ResourceAttributeType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// <p>Task object encapsulating task information.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct Task {
    /// <p>Status of the task - Not Started, In-Progress, Complete.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::Status>,
    /// <p>Details of task status as notified by a migration tool. A tool might use this field to provide clarifying information about the status that is unique to that tool or that explains an error state.</p>
    #[doc(hidden)]
    pub status_detail: std::option::Option<std::string::String>,
    /// <p>Indication of the percentage completion of the task.</p>
    #[doc(hidden)]
    pub progress_percent: std::option::Option<i32>,
}
impl Task {
    /// <p>Status of the task - Not Started, In-Progress, Complete.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::Status> {
        self.status.as_ref()
    }
    /// <p>Details of task status as notified by a migration tool. A tool might use this field to provide clarifying information about the status that is unique to that tool or that explains an error state.</p>
    pub fn status_detail(&self) -> std::option::Option<&str> {
        self.status_detail.as_deref()
    }
    /// <p>Indication of the percentage completion of the task.</p>
    pub fn progress_percent(&self) -> std::option::Option<i32> {
        self.progress_percent
    }
}
/// See [`Task`](crate::model::Task).
pub mod task {

    /// A builder for [`Task`](crate::model::Task).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) status: std::option::Option<crate::model::Status>,
        pub(crate) status_detail: std::option::Option<std::string::String>,
        pub(crate) progress_percent: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>Status of the task - Not Started, In-Progress, Complete.</p>
        pub fn status(mut self, input: crate::model::Status) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>Status of the task - Not Started, In-Progress, Complete.</p>
        pub fn set_status(mut self, input: std::option::Option<crate::model::Status>) -> Self {
            self.status = input;
            self
        }
        /// <p>Details of task status as notified by a migration tool. A tool might use this field to provide clarifying information about the status that is unique to that tool or that explains an error state.</p>
        pub fn status_detail(mut self, input: impl Into<std::string::String>) -> Self {
            self.status_detail = Some(input.into());
            self
        }
        /// <p>Details of task status as notified by a migration tool. A tool might use this field to provide clarifying information about the status that is unique to that tool or that explains an error state.</p>
        pub fn set_status_detail(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.status_detail = input;
            self
        }
        /// <p>Indication of the percentage completion of the task.</p>
        pub fn progress_percent(mut self, input: i32) -> Self {
            self.progress_percent = Some(input);
            self
        }
        /// <p>Indication of the percentage completion of the task.</p>
        pub fn set_progress_percent(mut self, input: std::option::Option<i32>) -> Self {
            self.progress_percent = input;
            self
        }
        /// Consumes the builder and constructs a [`Task`](crate::model::Task).
        pub fn build(self) -> crate::model::Task {
            crate::model::Task {
                status: self.status,
                status_detail: self.status_detail,
                progress_percent: self.progress_percent,
            }
        }
    }
}
impl Task {
    /// Creates a new builder-style object to manufacture [`Task`](crate::model::Task).
    pub fn builder() -> crate::model::task::Builder {
        crate::model::task::Builder::default()
    }
}

/// When writing a match expression against `Status`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let status = unimplemented!();
/// match status {
///     Status::Completed => { /* ... */ },
///     Status::Failed => { /* ... */ },
///     Status::InProgress => { /* ... */ },
///     Status::NotStarted => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `status` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `Status::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `Status::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `Status::NewFeature` is defined.
/// Specifically, when `status` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `Status::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum Status {
    #[allow(missing_docs)] // documentation missing in model
    Completed,
    #[allow(missing_docs)] // documentation missing in model
    Failed,
    #[allow(missing_docs)] // documentation missing in model
    InProgress,
    #[allow(missing_docs)] // documentation missing in model
    NotStarted,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for Status {
    fn from(s: &str) -> Self {
        match s {
            "COMPLETED" => Status::Completed,
            "FAILED" => Status::Failed,
            "IN_PROGRESS" => Status::InProgress,
            "NOT_STARTED" => Status::NotStarted,
            other => Status::Unknown(crate::types::UnknownVariantValue(other.to_owned())),
        }
    }
}
impl std::str::FromStr for Status {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(Status::from(s))
    }
}
impl Status {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            Status::Completed => "COMPLETED",
            Status::Failed => "FAILED",
            Status::InProgress => "IN_PROGRESS",
            Status::NotStarted => "NOT_STARTED",
            Status::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` values of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["COMPLETED", "FAILED", "IN_PROGRESS", "NOT_STARTED"]
    }
}
impl AsRef<str> for Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// When writing a match expression against `ApplicationStatus`, it is important to ensure
/// your code is forward-compatible. That is, if a match arm handles a case for a
/// feature that is supported by the service but has not been represented as an enum
/// variant in a current version of SDK, your code should continue to work when you
/// upgrade SDK to a future version in which the enum does include a variant for that
/// feature.
///
/// Here is an example of how you can make a match expression forward-compatible:
///
/// ```text
/// # let applicationstatus = unimplemented!();
/// match applicationstatus {
///     ApplicationStatus::Completed => { /* ... */ },
///     ApplicationStatus::InProgress => { /* ... */ },
///     ApplicationStatus::NotStarted => { /* ... */ },
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
///     _ => { /* ... */ },
/// }
/// ```
/// The above code demonstrates that when `applicationstatus` represents
/// `NewFeature`, the execution path will lead to the second last match arm,
/// even though the enum does not contain a variant `ApplicationStatus::NewFeature`
/// in the current version of SDK. The reason is that the variable `other`,
/// created by the `@` operator, is bound to
/// `ApplicationStatus::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
/// and calling `as_str` on it yields `"NewFeature"`.
/// This match expression is forward-compatible when executed with a newer
/// version of SDK where the variant `ApplicationStatus::NewFeature` is defined.
/// Specifically, when `applicationstatus` represents `NewFeature`,
/// the execution path will hit the second last match arm as before by virtue of
/// calling `as_str` on `ApplicationStatus::NewFeature` also yielding `"NewFeature"`.
///
/// Explicitly matching on the `Unknown` variant should
/// be avoided for two reasons:
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
/// - It might inadvertently shadow other intended match arms.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(
    std::clone::Clone,
    std::cmp::Eq,
    std::cmp::Ord,
    std::cmp::PartialEq,
    std::cmp::PartialOrd,
    std::fmt::Debug,
    std::hash::Hash,
)]
pub enum ApplicationStatus {
    #[allow(missing_docs)] // documentation missing in model
    Completed,
    #[allow(missing_docs)] // documentation missing in model
    InProgress,
    #[allow(missing_docs)] // documentation missing in model
    NotStarted,
    /// `Unknown` contains new variants that have been added since this code was generated.
    Unknown(crate::types::UnknownVariantValue),
}
impl std::convert::From<&str> for ApplicationStatus {
    fn from(s: &str) -> Self {
        match s {
            "COMPLETED" => ApplicationStatus::Completed,
            "IN_PROGRESS" => ApplicationStatus::InProgress,
            "NOT_STARTED" => ApplicationStatus::NotStarted,
            other => {
                ApplicationStatus::Unknown(crate::types::UnknownVariantValue(other.to_owned()))
            }
        }
    }
}
impl std::str::FromStr for ApplicationStatus {
    type Err = std::convert::Infallible;

    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        Ok(ApplicationStatus::from(s))
    }
}
impl ApplicationStatus {
    /// Returns the `&str` value of the enum member.
    pub fn as_str(&self) -> &str {
        match self {
            ApplicationStatus::Completed => "COMPLETED",
            ApplicationStatus::InProgress => "IN_PROGRESS",
            ApplicationStatus::NotStarted => "NOT_STARTED",
            ApplicationStatus::Unknown(value) => value.as_str(),
        }
    }
    /// Returns all the `&str` values of the enum members.
    pub const fn values() -> &'static [&'static str] {
        &["COMPLETED", "IN_PROGRESS", "NOT_STARTED"]
    }
}
impl AsRef<str> for ApplicationStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

/// <p>Summary of the AWS resource used for access control that is implicitly linked to your AWS account.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ProgressUpdateStreamSummary {
    /// <p>The name of the ProgressUpdateStream. <i>Do not store personal data in this field.</i> </p>
    #[doc(hidden)]
    pub progress_update_stream_name: std::option::Option<std::string::String>,
}
impl ProgressUpdateStreamSummary {
    /// <p>The name of the ProgressUpdateStream. <i>Do not store personal data in this field.</i> </p>
    pub fn progress_update_stream_name(&self) -> std::option::Option<&str> {
        self.progress_update_stream_name.as_deref()
    }
}
/// See [`ProgressUpdateStreamSummary`](crate::model::ProgressUpdateStreamSummary).
pub mod progress_update_stream_summary {

    /// A builder for [`ProgressUpdateStreamSummary`](crate::model::ProgressUpdateStreamSummary).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) progress_update_stream_name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The name of the ProgressUpdateStream. <i>Do not store personal data in this field.</i> </p>
        pub fn progress_update_stream_name(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.progress_update_stream_name = Some(input.into());
            self
        }
        /// <p>The name of the ProgressUpdateStream. <i>Do not store personal data in this field.</i> </p>
        pub fn set_progress_update_stream_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.progress_update_stream_name = input;
            self
        }
        /// Consumes the builder and constructs a [`ProgressUpdateStreamSummary`](crate::model::ProgressUpdateStreamSummary).
        pub fn build(self) -> crate::model::ProgressUpdateStreamSummary {
            crate::model::ProgressUpdateStreamSummary {
                progress_update_stream_name: self.progress_update_stream_name,
            }
        }
    }
}
impl ProgressUpdateStreamSummary {
    /// Creates a new builder-style object to manufacture [`ProgressUpdateStreamSummary`](crate::model::ProgressUpdateStreamSummary).
    pub fn builder() -> crate::model::progress_update_stream_summary::Builder {
        crate::model::progress_update_stream_summary::Builder::default()
    }
}

/// <p>MigrationTaskSummary includes <code>MigrationTaskName</code>, <code>ProgressPercent</code>, <code>ProgressUpdateStream</code>, <code>Status</code>, and <code>UpdateDateTime</code> for each task.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct MigrationTaskSummary {
    /// <p>An AWS resource used for access control. It should uniquely identify the migration tool as it is used for all updates made by the tool.</p>
    #[doc(hidden)]
    pub progress_update_stream: std::option::Option<std::string::String>,
    /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
    #[doc(hidden)]
    pub migration_task_name: std::option::Option<std::string::String>,
    /// <p>Status of the task.</p>
    #[doc(hidden)]
    pub status: std::option::Option<crate::model::Status>,
    /// <p>Indication of the percentage completion of the task.</p>
    #[doc(hidden)]
    pub progress_percent: std::option::Option<i32>,
    /// <p>Detail information of what is being done within the overall status state.</p>
    #[doc(hidden)]
    pub status_detail: std::option::Option<std::string::String>,
    /// <p>The timestamp when the task was gathered.</p>
    #[doc(hidden)]
    pub update_date_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl MigrationTaskSummary {
    /// <p>An AWS resource used for access control. It should uniquely identify the migration tool as it is used for all updates made by the tool.</p>
    pub fn progress_update_stream(&self) -> std::option::Option<&str> {
        self.progress_update_stream.as_deref()
    }
    /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
    pub fn migration_task_name(&self) -> std::option::Option<&str> {
        self.migration_task_name.as_deref()
    }
    /// <p>Status of the task.</p>
    pub fn status(&self) -> std::option::Option<&crate::model::Status> {
        self.status.as_ref()
    }
    /// <p>Indication of the percentage completion of the task.</p>
    pub fn progress_percent(&self) -> std::option::Option<i32> {
        self.progress_percent
    }
    /// <p>Detail information of what is being done within the overall status state.</p>
    pub fn status_detail(&self) -> std::option::Option<&str> {
        self.status_detail.as_deref()
    }
    /// <p>The timestamp when the task was gathered.</p>
    pub fn update_date_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.update_date_time.as_ref()
    }
}
/// See [`MigrationTaskSummary`](crate::model::MigrationTaskSummary).
pub mod migration_task_summary {

    /// A builder for [`MigrationTaskSummary`](crate::model::MigrationTaskSummary).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) progress_update_stream: std::option::Option<std::string::String>,
        pub(crate) migration_task_name: std::option::Option<std::string::String>,
        pub(crate) status: std::option::Option<crate::model::Status>,
        pub(crate) progress_percent: std::option::Option<i32>,
        pub(crate) status_detail: std::option::Option<std::string::String>,
        pub(crate) update_date_time: std::option::Option<aws_smithy_types::DateTime>,
    }
    impl Builder {
        /// <p>An AWS resource used for access control. It should uniquely identify the migration tool as it is used for all updates made by the tool.</p>
        pub fn progress_update_stream(mut self, input: impl Into<std::string::String>) -> Self {
            self.progress_update_stream = Some(input.into());
            self
        }
        /// <p>An AWS resource used for access control. It should uniquely identify the migration tool as it is used for all updates made by the tool.</p>
        pub fn set_progress_update_stream(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.progress_update_stream = input;
            self
        }
        /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
        pub fn migration_task_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.migration_task_name = Some(input.into());
            self
        }
        /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
        pub fn set_migration_task_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.migration_task_name = input;
            self
        }
        /// <p>Status of the task.</p>
        pub fn status(mut self, input: crate::model::Status) -> Self {
            self.status = Some(input);
            self
        }
        /// <p>Status of the task.</p>
        pub fn set_status(mut self, input: std::option::Option<crate::model::Status>) -> Self {
            self.status = input;
            self
        }
        /// <p>Indication of the percentage completion of the task.</p>
        pub fn progress_percent(mut self, input: i32) -> Self {
            self.progress_percent = Some(input);
            self
        }
        /// <p>Indication of the percentage completion of the task.</p>
        pub fn set_progress_percent(mut self, input: std::option::Option<i32>) -> Self {
            self.progress_percent = input;
            self
        }
        /// <p>Detail information of what is being done within the overall status state.</p>
        pub fn status_detail(mut self, input: impl Into<std::string::String>) -> Self {
            self.status_detail = Some(input.into());
            self
        }
        /// <p>Detail information of what is being done within the overall status state.</p>
        pub fn set_status_detail(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.status_detail = input;
            self
        }
        /// <p>The timestamp when the task was gathered.</p>
        pub fn update_date_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.update_date_time = Some(input);
            self
        }
        /// <p>The timestamp when the task was gathered.</p>
        pub fn set_update_date_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.update_date_time = input;
            self
        }
        /// Consumes the builder and constructs a [`MigrationTaskSummary`](crate::model::MigrationTaskSummary).
        pub fn build(self) -> crate::model::MigrationTaskSummary {
            crate::model::MigrationTaskSummary {
                progress_update_stream: self.progress_update_stream,
                migration_task_name: self.migration_task_name,
                status: self.status,
                progress_percent: self.progress_percent,
                status_detail: self.status_detail,
                update_date_time: self.update_date_time,
            }
        }
    }
}
impl MigrationTaskSummary {
    /// Creates a new builder-style object to manufacture [`MigrationTaskSummary`](crate::model::MigrationTaskSummary).
    pub fn builder() -> crate::model::migration_task_summary::Builder {
        crate::model::migration_task_summary::Builder::default()
    }
}

/// <p>Object representing the on-premises resource being migrated.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DiscoveredResource {
    /// <p>The configurationId in Application Discovery Service that uniquely identifies the on-premise resource.</p>
    #[doc(hidden)]
    pub configuration_id: std::option::Option<std::string::String>,
    /// <p>A description that can be free-form text to record additional detail about the discovered resource for clarity or later reference.</p>
    #[doc(hidden)]
    pub description: std::option::Option<std::string::String>,
}
impl DiscoveredResource {
    /// <p>The configurationId in Application Discovery Service that uniquely identifies the on-premise resource.</p>
    pub fn configuration_id(&self) -> std::option::Option<&str> {
        self.configuration_id.as_deref()
    }
    /// <p>A description that can be free-form text to record additional detail about the discovered resource for clarity or later reference.</p>
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
}
/// See [`DiscoveredResource`](crate::model::DiscoveredResource).
pub mod discovered_resource {

    /// A builder for [`DiscoveredResource`](crate::model::DiscoveredResource).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_id: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The configurationId in Application Discovery Service that uniquely identifies the on-premise resource.</p>
        pub fn configuration_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.configuration_id = Some(input.into());
            self
        }
        /// <p>The configurationId in Application Discovery Service that uniquely identifies the on-premise resource.</p>
        pub fn set_configuration_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.configuration_id = input;
            self
        }
        /// <p>A description that can be free-form text to record additional detail about the discovered resource for clarity or later reference.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        /// <p>A description that can be free-form text to record additional detail about the discovered resource for clarity or later reference.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`DiscoveredResource`](crate::model::DiscoveredResource).
        pub fn build(self) -> crate::model::DiscoveredResource {
            crate::model::DiscoveredResource {
                configuration_id: self.configuration_id,
                description: self.description,
            }
        }
    }
}
impl DiscoveredResource {
    /// Creates a new builder-style object to manufacture [`DiscoveredResource`](crate::model::DiscoveredResource).
    pub fn builder() -> crate::model::discovered_resource::Builder {
        crate::model::discovered_resource::Builder::default()
    }
}

/// <p>An ARN of the AWS cloud resource target receiving the migration (e.g., AMI, EC2 instance, RDS instance, etc.).</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct CreatedArtifact {
    /// <p>An ARN that uniquely identifies the result of a migration task.</p>
    #[doc(hidden)]
    pub name: std::option::Option<std::string::String>,
    /// <p>A description that can be free-form text to record additional detail about the artifact for clarity or for later reference.</p>
    #[doc(hidden)]
    pub description: std::option::Option<std::string::String>,
}
impl CreatedArtifact {
    /// <p>An ARN that uniquely identifies the result of a migration task.</p>
    pub fn name(&self) -> std::option::Option<&str> {
        self.name.as_deref()
    }
    /// <p>A description that can be free-form text to record additional detail about the artifact for clarity or for later reference.</p>
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
}
/// See [`CreatedArtifact`](crate::model::CreatedArtifact).
pub mod created_artifact {

    /// A builder for [`CreatedArtifact`](crate::model::CreatedArtifact).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) name: std::option::Option<std::string::String>,
        pub(crate) description: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>An ARN that uniquely identifies the result of a migration task.</p>
        pub fn name(mut self, input: impl Into<std::string::String>) -> Self {
            self.name = Some(input.into());
            self
        }
        /// <p>An ARN that uniquely identifies the result of a migration task.</p>
        pub fn set_name(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.name = input;
            self
        }
        /// <p>A description that can be free-form text to record additional detail about the artifact for clarity or for later reference.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        /// <p>A description that can be free-form text to record additional detail about the artifact for clarity or for later reference.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// Consumes the builder and constructs a [`CreatedArtifact`](crate::model::CreatedArtifact).
        pub fn build(self) -> crate::model::CreatedArtifact {
            crate::model::CreatedArtifact {
                name: self.name,
                description: self.description,
            }
        }
    }
}
impl CreatedArtifact {
    /// Creates a new builder-style object to manufacture [`CreatedArtifact`](crate::model::CreatedArtifact).
    pub fn builder() -> crate::model::created_artifact::Builder {
        crate::model::created_artifact::Builder::default()
    }
}

/// <p>The state of an application discovered through Migration Hub import, the AWS Agentless Discovery Connector, or the AWS Application Discovery Agent.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ApplicationState {
    /// <p>The configurationId from the Application Discovery Service that uniquely identifies an application.</p>
    #[doc(hidden)]
    pub application_id: std::option::Option<std::string::String>,
    /// <p>The current status of an application.</p>
    #[doc(hidden)]
    pub application_status: std::option::Option<crate::model::ApplicationStatus>,
    /// <p>The timestamp when the application status was last updated.</p>
    #[doc(hidden)]
    pub last_updated_time: std::option::Option<aws_smithy_types::DateTime>,
}
impl ApplicationState {
    /// <p>The configurationId from the Application Discovery Service that uniquely identifies an application.</p>
    pub fn application_id(&self) -> std::option::Option<&str> {
        self.application_id.as_deref()
    }
    /// <p>The current status of an application.</p>
    pub fn application_status(&self) -> std::option::Option<&crate::model::ApplicationStatus> {
        self.application_status.as_ref()
    }
    /// <p>The timestamp when the application status was last updated.</p>
    pub fn last_updated_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_updated_time.as_ref()
    }
}
/// See [`ApplicationState`](crate::model::ApplicationState).
pub mod application_state {

    /// A builder for [`ApplicationState`](crate::model::ApplicationState).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) application_id: std::option::Option<std::string::String>,
        pub(crate) application_status: std::option::Option<crate::model::ApplicationStatus>,
        pub(crate) last_updated_time: std::option::Option<aws_smithy_types::DateTime>,
    }
    impl Builder {
        /// <p>The configurationId from the Application Discovery Service that uniquely identifies an application.</p>
        pub fn application_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.application_id = Some(input.into());
            self
        }
        /// <p>The configurationId from the Application Discovery Service that uniquely identifies an application.</p>
        pub fn set_application_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.application_id = input;
            self
        }
        /// <p>The current status of an application.</p>
        pub fn application_status(mut self, input: crate::model::ApplicationStatus) -> Self {
            self.application_status = Some(input);
            self
        }
        /// <p>The current status of an application.</p>
        pub fn set_application_status(
            mut self,
            input: std::option::Option<crate::model::ApplicationStatus>,
        ) -> Self {
            self.application_status = input;
            self
        }
        /// <p>The timestamp when the application status was last updated.</p>
        pub fn last_updated_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_updated_time = Some(input);
            self
        }
        /// <p>The timestamp when the application status was last updated.</p>
        pub fn set_last_updated_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_updated_time = input;
            self
        }
        /// Consumes the builder and constructs a [`ApplicationState`](crate::model::ApplicationState).
        pub fn build(self) -> crate::model::ApplicationState {
            crate::model::ApplicationState {
                application_id: self.application_id,
                application_status: self.application_status,
                last_updated_time: self.last_updated_time,
            }
        }
    }
}
impl ApplicationState {
    /// Creates a new builder-style object to manufacture [`ApplicationState`](crate::model::ApplicationState).
    pub fn builder() -> crate::model::application_state::Builder {
        crate::model::application_state::Builder::default()
    }
}

/// <p>Represents a migration task in a migration tool.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct MigrationTask {
    /// <p>A name that identifies the vendor of the migration tool being used.</p>
    #[doc(hidden)]
    pub progress_update_stream: std::option::Option<std::string::String>,
    /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
    #[doc(hidden)]
    pub migration_task_name: std::option::Option<std::string::String>,
    /// <p>Task object encapsulating task information.</p>
    #[doc(hidden)]
    pub task: std::option::Option<crate::model::Task>,
    /// <p>The timestamp when the task was gathered.</p>
    #[doc(hidden)]
    pub update_date_time: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>Information about the resource that is being migrated. This data will be used to map the task to a resource in the Application Discovery Service repository.</p>
    #[doc(hidden)]
    pub resource_attribute_list:
        std::option::Option<std::vec::Vec<crate::model::ResourceAttribute>>,
}
impl MigrationTask {
    /// <p>A name that identifies the vendor of the migration tool being used.</p>
    pub fn progress_update_stream(&self) -> std::option::Option<&str> {
        self.progress_update_stream.as_deref()
    }
    /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
    pub fn migration_task_name(&self) -> std::option::Option<&str> {
        self.migration_task_name.as_deref()
    }
    /// <p>Task object encapsulating task information.</p>
    pub fn task(&self) -> std::option::Option<&crate::model::Task> {
        self.task.as_ref()
    }
    /// <p>The timestamp when the task was gathered.</p>
    pub fn update_date_time(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.update_date_time.as_ref()
    }
    /// <p>Information about the resource that is being migrated. This data will be used to map the task to a resource in the Application Discovery Service repository.</p>
    pub fn resource_attribute_list(
        &self,
    ) -> std::option::Option<&[crate::model::ResourceAttribute]> {
        self.resource_attribute_list.as_deref()
    }
}
/// See [`MigrationTask`](crate::model::MigrationTask).
pub mod migration_task {

    /// A builder for [`MigrationTask`](crate::model::MigrationTask).
    #[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) progress_update_stream: std::option::Option<std::string::String>,
        pub(crate) migration_task_name: std::option::Option<std::string::String>,
        pub(crate) task: std::option::Option<crate::model::Task>,
        pub(crate) update_date_time: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) resource_attribute_list:
            std::option::Option<std::vec::Vec<crate::model::ResourceAttribute>>,
    }
    impl Builder {
        /// <p>A name that identifies the vendor of the migration tool being used.</p>
        pub fn progress_update_stream(mut self, input: impl Into<std::string::String>) -> Self {
            self.progress_update_stream = Some(input.into());
            self
        }
        /// <p>A name that identifies the vendor of the migration tool being used.</p>
        pub fn set_progress_update_stream(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.progress_update_stream = input;
            self
        }
        /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
        pub fn migration_task_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.migration_task_name = Some(input.into());
            self
        }
        /// <p>Unique identifier that references the migration task. <i>Do not store personal data in this field.</i> </p>
        pub fn set_migration_task_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.migration_task_name = input;
            self
        }
        /// <p>Task object encapsulating task information.</p>
        pub fn task(mut self, input: crate::model::Task) -> Self {
            self.task = Some(input);
            self
        }
        /// <p>Task object encapsulating task information.</p>
        pub fn set_task(mut self, input: std::option::Option<crate::model::Task>) -> Self {
            self.task = input;
            self
        }
        /// <p>The timestamp when the task was gathered.</p>
        pub fn update_date_time(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.update_date_time = Some(input);
            self
        }
        /// <p>The timestamp when the task was gathered.</p>
        pub fn set_update_date_time(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.update_date_time = input;
            self
        }
        /// Appends an item to `resource_attribute_list`.
        ///
        /// To override the contents of this collection use [`set_resource_attribute_list`](Self::set_resource_attribute_list).
        ///
        /// <p>Information about the resource that is being migrated. This data will be used to map the task to a resource in the Application Discovery Service repository.</p>
        pub fn resource_attribute_list(mut self, input: crate::model::ResourceAttribute) -> Self {
            let mut v = self.resource_attribute_list.unwrap_or_default();
            v.push(input);
            self.resource_attribute_list = Some(v);
            self
        }
        /// <p>Information about the resource that is being migrated. This data will be used to map the task to a resource in the Application Discovery Service repository.</p>
        pub fn set_resource_attribute_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourceAttribute>>,
        ) -> Self {
            self.resource_attribute_list = input;
            self
        }
        /// Consumes the builder and constructs a [`MigrationTask`](crate::model::MigrationTask).
        pub fn build(self) -> crate::model::MigrationTask {
            crate::model::MigrationTask {
                progress_update_stream: self.progress_update_stream,
                migration_task_name: self.migration_task_name,
                task: self.task,
                update_date_time: self.update_date_time,
                resource_attribute_list: self.resource_attribute_list,
            }
        }
    }
}
impl MigrationTask {
    /// Creates a new builder-style object to manufacture [`MigrationTask`](crate::model::MigrationTask).
    pub fn builder() -> crate::model::migration_task::Builder {
        crate::model::migration_task::Builder::default()
    }
}