Server Test

#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::hash::Hash)]

pub struct StartSnapshotInput {

    /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>

    /// <ul>

    /// <li>

    /// <p>No blocks are written to the snapshot.</p></li>

    /// <li>

    /// <p>The snapshot is not completed after writing the last block of data.</p></li>

    /// </ul>

    /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>

    pub timeout: ::std::option::Option<crate::model::Timeout>,

    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>

    /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>

    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub client_token: ::std::option::Option<crate::model::IdempotencyToken>,

    /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>

    pub volume_size: crate::model::VolumeSize,

    /// <p>The tags to apply to the snapshot.</p>

    pub tags: ::std::option::Option<::std::vec::Vec<crate::model::Tag>>,

    /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>

    /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>

    /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>

    /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>

    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub encrypted: ::std::option::Option<bool>,

    /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>

    /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>

    /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>

    pub kms_key_arn: ::std::option::Option<crate::model::KmsKeyArn>,

    /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>

    /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>

    pub parent_snapshot_id: ::std::option::Option<crate::model::SnapshotId>,

    /// <p>A description for the snapshot.</p>

    pub description: ::std::option::Option<crate::model::Description>,

}

impl StartSnapshotInput {

    /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>

    /// <ul>

    /// <li>

    /// <p>No blocks are written to the snapshot.</p></li>

    /// <li>

    /// <p>The snapshot is not completed after writing the last block of data.</p></li>

    /// </ul>

    /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>

    pub fn timeout(&self) -> ::std::option::Option<&crate::model::Timeout> {

        self.timeout.as_ref()

    }

    /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>

    /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>

    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub fn client_token(&self) -> ::std::option::Option<&crate::model::IdempotencyToken> {

        self.client_token.as_ref()

    }

    /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>

    pub fn volume_size(&self) -> &crate::model::VolumeSize {

        &self.volume_size

    }

    /// <p>The tags to apply to the snapshot.</p>

    pub fn tags(&self) -> ::std::option::Option<&[crate::model::Tag]> {

        self.tags.as_deref()

    }

    /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>

    /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>

    /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>

    /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>

    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub fn encrypted(&self) -> ::std::option::Option<bool> {

        self.encrypted

    }

    /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>

    /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>

    /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>

    pub fn kms_key_arn(&self) -> ::std::option::Option<&crate::model::KmsKeyArn> {

        self.kms_key_arn.as_ref()

    }

    /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>

    /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>

    pub fn parent_snapshot_id(&self) -> ::std::option::Option<&crate::model::SnapshotId> {

        self.parent_snapshot_id.as_ref()

    }

    /// <p>A description for the snapshot.</p>

    pub fn description(&self) -> ::std::option::Option<&crate::model::Description> {

        self.description.as_ref()

    }

impl ::std::fmt::Debug for StartSnapshotInput {

    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {

        let mut formatter = f.debug_struct("StartSnapshotInput");

        formatter.field("timeout", &self.timeout);

        formatter.field("client_token", &self.client_token);

        formatter.field("volume_size", &self.volume_size);

        formatter.field("tags", &self.tags);

        formatter.field("encrypted", &self.encrypted);

        formatter.field("kms_key_arn", &"*** Sensitive Data Redacted ***");

        formatter.field("parent_snapshot_id", &self.parent_snapshot_id);

        formatter.field("description", &self.description);

        formatter.finish()

}

impl StartSnapshotInput {

    /// Creates a new builder-style object to manufacture [`StartSnapshotInput`](crate::input::StartSnapshotInput).

    pub fn builder() -> crate::input::start_snapshot_input::Builder {

        crate::input::start_snapshot_input::Builder::default()

}

impl crate::constrained::Constrained for crate::input::StartSnapshotInput {

    type Unconstrained = crate::input::start_snapshot_input::Builder;

}

#[allow(missing_docs)] // documentation missing in model

pub struct PutSnapshotBlockInput {

    /// <p>The ID of the snapshot.</p>

    pub snapshot_id: crate::model::SnapshotId,

    /// <p>The block index of the block in which to write the data. A block index is a logical index in units of <code>512</code> KiB blocks. To identify the block index, divide the logical offset of the data in the logical volume by the block size (logical offset of data/<code>524288</code>). The logical offset of the data must be <code>512</code> KiB aligned.</p>

    pub block_index: crate::model::BlockIndex,

    /// <p>A Base64-encoded SHA256 checksum of the data. Only SHA256 checksums are supported.</p>

    pub checksum: crate::model::Checksum,

    /// <p>The progress of the write process, as a percentage.</p>

    pub progress: ::std::option::Option<crate::model::Progress>,

    /// <p>The data to write to the block.</p>

    /// <p>The block data is not signed as part of the Signature Version 4 signing process. As a result, you must generate and provide a Base64-encoded SHA256 checksum for the block data using the <b>x-amz-Checksum</b> header. Also, you must specify the checksum algorithm using the <b>x-amz-Checksum-Algorithm</b> header. The checksum that you provide is part of the Signature Version 4 signing process. It is validated against a checksum generated by Amazon EBS to ensure the validity and authenticity of the data. If the checksums do not correspond, the request fails. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-checksums"> Using checksums with the EBS direct APIs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub block_data: ::aws_smithy_types::byte_stream::ByteStream,

    /// <p>The size of the data to write to the block, in bytes. Currently, the only supported size is <code>524288</code>.</p>

    /// <p>Valid values: <code>524288</code></p>

    pub data_length: i32,

    pub checksum_algorithm: crate::model::ChecksumAlgorithm,

}

impl PutSnapshotBlockInput {

    /// <p>The block index of the block in which to write the data. A block index is a logical index in units of <code>512</code> KiB blocks. To identify the block index, divide the logical offset of the data in the logical volume by the block size (logical offset of data/<code>524288</code>). The logical offset of the data must be <code>512</code> KiB aligned.</p>

    pub fn block_index(&self) -> &crate::model::BlockIndex {

        &self.block_index

    }

    /// <p>A Base64-encoded SHA256 checksum of the data. Only SHA256 checksums are supported.</p>

    pub fn checksum(&self) -> &crate::model::Checksum {

        &self.checksum

    }

    /// <p>The progress of the write process, as a percentage.</p>

    pub fn progress(&self) -> ::std::option::Option<&crate::model::Progress> {

        self.progress.as_ref()

    }

    /// <p>The data to write to the block.</p>

    /// <p>The block data is not signed as part of the Signature Version 4 signing process. As a result, you must generate and provide a Base64-encoded SHA256 checksum for the block data using the <b>x-amz-Checksum</b> header. Also, you must specify the checksum algorithm using the <b>x-amz-Checksum-Algorithm</b> header. The checksum that you provide is part of the Signature Version 4 signing process. It is validated against a checksum generated by Amazon EBS to ensure the validity and authenticity of the data. If the checksums do not correspond, the request fails. For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-checksums"> Using checksums with the EBS direct APIs</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

    pub fn block_data(&self) -> &::aws_smithy_types::byte_stream::ByteStream {

        &self.block_data

    }

    /// <p>The size of the data to write to the block, in bytes. Currently, the only supported size is <code>524288</code>.</p>

    /// <p>Valid values: <code>524288</code></p>

    pub fn data_length(&self) -> i32 {

        self.data_length

    }

    /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>

    pub fn checksum_algorithm(&self) -> &crate::model::ChecksumAlgorithm {

        &self.checksum_algorithm

    }

}

impl ::std::fmt::Debug for PutSnapshotBlockInput {

    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {

        let mut formatter = f.debug_struct("PutSnapshotBlockInput");

        formatter.field("snapshot_id", &self.snapshot_id);

        formatter.field("block_index", &self.block_index);

        formatter.field("checksum", &self.checksum);

        formatter.field("progress", &self.progress);

        formatter.field("block_data", &"*** Sensitive Data Redacted ***");

        formatter.field("data_length", &self.data_length);

        formatter.field("checksum_algorithm", &self.checksum_algorithm);

        formatter.finish()

impl PutSnapshotBlockInput {

    /// Creates a new builder-style object to manufacture [`PutSnapshotBlockInput`](crate::input::PutSnapshotBlockInput).

    pub fn builder() -> crate::input::put_snapshot_block_input::Builder {

        crate::input::put_snapshot_block_input::Builder::default()

impl crate::constrained::Constrained for crate::input::PutSnapshotBlockInput {

    type Unconstrained = crate::input::put_snapshot_block_input::Builder;

pub struct ListSnapshotBlocksInput {

    /// <p>The number of results to return.</p>

    pub max_results: ::std::option::Option<crate::model::MaxResults>,

    /// <p>The block index from which the list should start. The list in the response will start from this block index or the next valid block index in the snapshot.</p>

    pub starting_block_index: ::std::option::Option<crate::model::BlockIndex>,

    /// <p>The token to request the next page of results.</p>

    pub next_token: ::std::option::Option<crate::model::PageToken>,

    /// <p>The ID of the snapshot from which to get block indexes and block tokens.</p>

impl ListSnapshotBlocksInput {

    /// <p>The number of results to return.</p>

    pub fn max_results(&self) -> ::std::option::Option<&crate::model::MaxResults> {

        self.max_results.as_ref()

    }

    /// <p>The block index from which the list should start. The list in the response will start from this block index or the next valid block index in the snapshot.</p>

    pub fn starting_block_index(&self) -> ::std::option::Option<&crate::model::BlockIndex> {

        self.starting_block_index.as_ref()

    }

    /// <p>The token to request the next page of results.</p>

    pub fn next_token(&self) -> ::std::option::Option<&crate::model::PageToken> {

        self.next_token.as_ref()

    }

    /// <p>The ID of the snapshot from which to get block indexes and block tokens.</p>

impl ListSnapshotBlocksInput {

    /// Creates a new builder-style object to manufacture [`ListSnapshotBlocksInput`](crate::input::ListSnapshotBlocksInput).

    pub fn builder() -> crate::input::list_snapshot_blocks_input::Builder {

        crate::input::list_snapshot_blocks_input::Builder::default()

impl crate::constrained::Constrained for crate::input::ListSnapshotBlocksInput {

    type Unconstrained = crate::input::list_snapshot_blocks_input::Builder;

pub struct GetSnapshotBlockInput {

    /// <p>The ID of the snapshot containing the block from which to get data.</p>

    /// <p>The block token of the block from which to get data.</p>

    /// <p>Obtain the <code>BlockToken</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>

    pub block_token: crate::model::BlockToken,

    /// <p>The block index of the block from which to get data.</p>

    /// <p>Obtain the <code>BlockIndex</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>

impl GetSnapshotBlockInput {

    /// <p>The ID of the snapshot containing the block from which to get data.</p>

    /// <p>The block token of the block from which to get data.</p>

    /// <p>Obtain the <code>BlockToken</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>

    pub fn block_token(&self) -> &crate::model::BlockToken {

        &self.block_token

    /// <p>The block index of the block from which to get data.</p>

    /// <p>Obtain the <code>BlockIndex</code> by running the <code>ListChangedBlocks</code> or <code>ListSnapshotBlocks</code> operations.</p>

    pub fn block_index(&self) -> &crate::model::BlockIndex {

        &self.block_index

}

impl GetSnapshotBlockInput {

    /// Creates a new builder-style object to manufacture [`GetSnapshotBlockInput`](crate::input::GetSnapshotBlockInput).

    pub fn builder() -> crate::input::get_snapshot_block_input::Builder {

        crate::input::get_snapshot_block_input::Builder::default()

}

impl crate::constrained::Constrained for crate::input::GetSnapshotBlockInput {

    type Unconstrained = crate::input::get_snapshot_block_input::Builder;

}

#[allow(missing_docs)] // documentation missing in model

#[derive(

    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,

)]

pub struct CompleteSnapshotInput {

    /// <p>The number of blocks that were written to the snapshot.</p>

    pub changed_blocks_count: crate::model::ChangedBlocksCount,

    /// <p>The aggregation method used to generate the checksum. Currently, the only supported aggregation method is <code>LINEAR</code>.</p>

    pub checksum_aggregation_method: ::std::option::Option<crate::model::ChecksumAggregationMethod>,

    /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>

    pub checksum_algorithm: ::std::option::Option<crate::model::ChecksumAlgorithm>,

    /// <p>The ID of the snapshot.</p>

    pub snapshot_id: crate::model::SnapshotId,

    /// <p>An aggregated Base-64 SHA256 checksum based on the checksums of each written block.</p>

    /// <p>To generate the aggregated checksum using the linear aggregation method, arrange the checksums for each written block in ascending order of their block index, concatenate them to form a single string, and then generate the checksum on the entire string using the SHA256 algorithm.</p>

    pub checksum: ::std::option::Option<crate::model::Checksum>,

}

impl CompleteSnapshotInput {

    /// <p>The number of blocks that were written to the snapshot.</p>

    pub fn changed_blocks_count(&self) -> &crate::model::ChangedBlocksCount {

        &self.changed_blocks_count

    /// <p>The aggregation method used to generate the checksum. Currently, the only supported aggregation method is <code>LINEAR</code>.</p>

    pub fn checksum_aggregation_method(

        &self,

    ) -> ::std::option::Option<&crate::model::ChecksumAggregationMethod> {

        self.checksum_aggregation_method.as_ref()

    /// <p>The algorithm used to generate the checksum. Currently, the only supported algorithm is <code>SHA256</code>.</p>

    pub fn checksum_algorithm(&self) -> ::std::option::Option<&crate::model::ChecksumAlgorithm> {

        self.checksum_algorithm.as_ref()

    /// <p>The ID of the snapshot.</p>

    pub fn snapshot_id(&self) -> &crate::model::SnapshotId {

        &self.snapshot_id

    /// <p>An aggregated Base-64 SHA256 checksum based on the checksums of each written block.</p>

    /// <p>To generate the aggregated checksum using the linear aggregation method, arrange the checksums for each written block in ascending order of their block index, concatenate them to form a single string, and then generate the checksum on the entire string using the SHA256 algorithm.</p>

    pub fn checksum(&self) -> ::std::option::Option<&crate::model::Checksum> {

        self.checksum.as_ref()

impl CompleteSnapshotInput {

    /// Creates a new builder-style object to manufacture [`CompleteSnapshotInput`](crate::input::CompleteSnapshotInput).

    pub fn builder() -> crate::input::complete_snapshot_input::Builder {

        crate::input::complete_snapshot_input::Builder::default()

impl crate::constrained::Constrained for crate::input::CompleteSnapshotInput {

    type Unconstrained = crate::input::complete_snapshot_input::Builder;

/// See [`StartSnapshotInput`](crate::input::StartSnapshotInput).

pub mod start_snapshot_input {

        /// Constraint violation occurred building member `timeout` when building `StartSnapshotInput`.

        #[doc(hidden)]

        Timeout(crate::model::timeout::ConstraintViolation),

        /// Constraint violation occurred building member `client_token` when building `StartSnapshotInput`.

        #[doc(hidden)]

        ClientToken(crate::model::idempotency_token::ConstraintViolation),

        /// `volume_size` was not provided but it is required when building `StartSnapshotInput`.

        MissingVolumeSize,

        /// Constraint violation occurred building member `volume_size` when building `StartSnapshotInput`.

        VolumeSize(crate::model::volume_size::ConstraintViolation),

        /// Constraint violation occurred building member `tags` when building `StartSnapshotInput`.

        Tags(crate::model::tags::ConstraintViolation),

        /// Constraint violation occurred building member `kms_key_arn` when building `StartSnapshotInput`.

        KmsKeyArn(crate::model::kms_key_arn::ConstraintViolation),

        /// Constraint violation occurred building member `parent_snapshot_id` when building `StartSnapshotInput`.

        ParentSnapshotId(crate::model::snapshot_id::ConstraintViolation),

        /// Constraint violation occurred building member `description` when building `StartSnapshotInput`.

        Description(crate::model::description::ConstraintViolation),

                ConstraintViolation::Timeout(_) => write!(f, "constraint violation occurred building member `timeout` when building `StartSnapshotInput`"),

                ConstraintViolation::ClientToken(_) => write!(f, "constraint violation occurred building member `client_token` when building `StartSnapshotInput`"),

                ConstraintViolation::MissingVolumeSize => write!(f, "`volume_size` was not provided but it is required when building `StartSnapshotInput`"),

                ConstraintViolation::VolumeSize(_) => write!(f, "constraint violation occurred building member `volume_size` when building `StartSnapshotInput`"),

                ConstraintViolation::Tags(_) => write!(f, "constraint violation occurred building member `tags` when building `StartSnapshotInput`"),

                ConstraintViolation::KmsKeyArn(_) => write!(f, "constraint violation occurred building member `kms_key_arn` when building `StartSnapshotInput`"),

                ConstraintViolation::ParentSnapshotId(_) => write!(f, "constraint violation occurred building member `parent_snapshot_id` when building `StartSnapshotInput`"),

                ConstraintViolation::Description(_) => write!(f, "constraint violation occurred building member `description` when building `StartSnapshotInput`"),

            ConstraintViolation::Timeout(inner) => inner.as_validation_exception_field(path + "/Timeout"),

            ConstraintViolation::ClientToken(inner) => inner.as_validation_exception_field(path + "/ClientToken"),

            ConstraintViolation::MissingVolumeSize => crate::model::ValidationExceptionField {

                                                message: format!("Value at '{}/VolumeSize' failed to satisfy constraint: Member must not be null", path),

                                                path: path + "/VolumeSize",

            ConstraintViolation::VolumeSize(inner) => inner.as_validation_exception_field(path + "/VolumeSize"),

            ConstraintViolation::Tags(inner) => inner.as_validation_exception_field(path + "/Tags"),

            ConstraintViolation::KmsKeyArn(inner) => inner.as_validation_exception_field(path + "/KmsKeyArn"),

            ConstraintViolation::ParentSnapshotId(inner) => inner.as_validation_exception_field(path + "/ParentSnapshotId"),

            ConstraintViolation::Description(inner) => inner.as_validation_exception_field(path + "/Description"),

        for crate::constrained::MaybeConstrained<crate::input::StartSnapshotInput>

    impl ::std::convert::TryFrom<Builder> for crate::input::StartSnapshotInput {

    /// A builder for [`StartSnapshotInput`](crate::input::StartSnapshotInput).

    #[derive(::std::clone::Clone, ::std::default::Default)]

    pub struct Builder {

        pub(crate) timeout:

            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Timeout>>,

        pub(crate) client_token: ::std::option::Option<

            crate::constrained::MaybeConstrained<crate::model::IdempotencyToken>,

        >,

        pub(crate) volume_size:

            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::VolumeSize>>,

        pub(crate) tags: ::std::option::Option<

            crate::constrained::MaybeConstrained<

                crate::constrained::tags_constrained::TagsConstrained,

            >,

        >,

        pub(crate) encrypted: ::std::option::Option<bool>,

        pub(crate) kms_key_arn:

            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::KmsKeyArn>>,

        pub(crate) parent_snapshot_id:

            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::SnapshotId>>,

        pub(crate) description:

            ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::Description>>,

    }

    impl Builder {

        /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>

        /// <ul>

        /// <li>

        /// <p>No blocks are written to the snapshot.</p></li>

        /// <li>

        /// <p>The snapshot is not completed after writing the last block of data.</p></li>

        /// </ul>

        /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>

        pub fn timeout(mut self, input: ::std::option::Option<crate::model::Timeout>) -> Self {

            self.timeout = input.map(crate::constrained::MaybeConstrained::Constrained);

            self

        }

        /// <p>The amount of time (in minutes) after which the snapshot is automatically cancelled if:</p>

        /// <ul>

        /// <li>

        /// <p>No blocks are written to the snapshot.</p></li>

        /// <li>

        /// <p>The snapshot is not completed after writing the last block of data.</p></li>

        /// </ul>

        /// <p>If no value is specified, the timeout defaults to <code>60</code> minutes.</p>

        pub(crate) fn set_timeout(

            mut self,

            input: Option<

                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::Timeout>>,

            >,

        ) -> Self {

            self.timeout = input.map(|v| v.into());

            self

        }

        /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>

        /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>

        /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

        pub fn client_token(

            mut self,

            input: ::std::option::Option<crate::model::IdempotencyToken>,

        ) -> Self {

            self.client_token = input.map(crate::constrained::MaybeConstrained::Constrained);

            self

        }

        /// <p>A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original request completes successfully. The subsequent retries with the same client token return the result from the original successful request and they have no additional effect.</p>

        /// <p>If you do not specify a client token, one is automatically generated by the AWS SDK.</p>

        /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-direct-api-idempotency.html"> Idempotency for StartSnapshot API</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

        pub(crate) fn set_client_token(

            mut self,

            input: Option<

                impl ::std::convert::Into<

                    crate::constrained::MaybeConstrained<crate::model::IdempotencyToken>,

        ) -> Self {

            self.client_token = input.map(|v| v.into());

            self

        /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>

        pub fn volume_size(mut self, input: crate::model::VolumeSize) -> Self {

            self.volume_size = Some(crate::constrained::MaybeConstrained::Constrained(input));

        /// <p>The size of the volume, in GiB. The maximum size is <code>16384</code> GiB (16 TiB).</p>

        pub(crate) fn set_volume_size(

                crate::constrained::MaybeConstrained<crate::model::VolumeSize>,

            self.volume_size = Some(input.into());

        /// <p>The tags to apply to the snapshot.</p>

        pub fn tags(

            input: ::std::option::Option<::std::vec::Vec<crate::model::Tag>>,

            self.tags =

                input.map(|v| crate::constrained::MaybeConstrained::Constrained((v).into()));

        /// <p>The tags to apply to the snapshot.</p>

        pub(crate) fn set_tags(

                    crate::constrained::MaybeConstrained<

                        crate::constrained::tags_constrained::TagsConstrained,

                    >,

            self.tags = input.map(|v| v.into());

            self

        }

        /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>

        /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>

        /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>

        /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>

        /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

        pub fn encrypted(mut self, input: ::std::option::Option<bool>) -> Self {

            self.encrypted = input;

            self

        }

        /// <p>Indicates whether to encrypt the snapshot. To create an encrypted snapshot, specify <code>true</code>. To create an unencrypted snapshot, omit this parameter.</p>

        /// <p>If you specify a value for <b>ParentSnapshotId</b>, omit this parameter.</p>

        /// <p>If you specify <code>true</code>, the snapshot is encrypted using the CMK specified using the <b>KmsKeyArn</b> parameter. If no value is specified for <b>KmsKeyArn</b>, the default CMK for your account is used. If no default CMK has been specified for your account, the AWS managed CMK is used. To set a default CMK for your account, use <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_ModifyEbsDefaultKmsKeyId.html"> ModifyEbsDefaultKmsKeyId</a>.</p>

        /// <p>If your account is enabled for encryption by default, you cannot set this parameter to <code>false</code>. In this case, you can omit this parameter.</p>

        /// <p>For more information, see <a href="https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-accessing-snapshot.html#ebsapis-using-encryption"> Using encryption</a> in the <i>Amazon Elastic Compute Cloud User Guide</i>.</p>

        pub(crate) fn set_encrypted(

            mut self,

            input: Option<impl ::std::convert::Into<bool>>,

        ) -> Self {

            self.encrypted = input.map(|v| v.into());

        /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>

        /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>

        /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>

        pub fn kms_key_arn(

            input: ::std::option::Option<crate::model::KmsKeyArn>,

            self.kms_key_arn = input.map(crate::constrained::MaybeConstrained::Constrained);

        /// <p>The Amazon Resource Name (ARN) of the AWS Key Management Service (AWS KMS) customer master key (CMK) to be used to encrypt the snapshot. If you do not specify a CMK, the default AWS managed CMK is used.</p>

        /// <p>If you specify a <b>ParentSnapshotId</b>, omit this parameter; the snapshot will be encrypted using the same CMK that was used to encrypt the parent snapshot.</p>

        /// <p>If <b>Encrypted</b> is set to <code>true</code>, you must specify a CMK ARN.</p>

        pub(crate) fn set_kms_key_arn(

                impl ::std::convert::Into<crate::constrained::MaybeConstrained<crate::model::KmsKeyArn>>,

            self.kms_key_arn = input.map(|v| v.into());

        /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>

        /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>

        pub fn parent_snapshot_id(

            mut self,

            input: ::std::option::Option<crate::model::SnapshotId>,

        ) -> Self {

            self.parent_snapshot_id = input.map(crate::constrained::MaybeConstrained::Constrained);

        /// <p>The ID of the parent snapshot. If there is no parent snapshot, or if you are creating the first snapshot for an on-premises volume, omit this parameter.</p>

        /// <p>If your account is enabled for encryption by default, you cannot use an unencrypted snapshot as a parent snapshot. You must first create an encrypted copy of the parent snapshot using <a href="https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CopySnapshot.html">CopySnapshot</a>.</p>

        pub(crate) fn set_parent_snapshot_id(

            input: Option<

                impl ::std::convert::Into<

            >,

            self.parent_snapshot_id = input.map(|v| v.into());

        /// <p>A description for the snapshot.</p>

        pub fn description(

            mut self,

            input: ::std::option::Option<crate::model::Description>,

        ) -> Self {

            self.description = input.map(crate::constrained::MaybeConstrained::Constrained);

        /// <p>A description for the snapshot.</p>

        pub(crate) fn set_description(

                impl ::std::convert::Into<

                    crate::constrained::MaybeConstrained<crate::model::Description>,

                >,

            self.description = input.map(|v| v.into());

        /// Consumes the builder and constructs a [`StartSnapshotInput`](crate::input::StartSnapshotInput).

        /// The builder fails to construct a [`StartSnapshotInput`](crate::input::StartSnapshotInput) if a [`ConstraintViolation`] occurs.

        pub fn build(self) -> Result<crate::input::StartSnapshotInput, ConstraintViolation> {

        ) -> Result<crate::input::StartSnapshotInput, ConstraintViolation> {

            Ok(crate::input::StartSnapshotInput {

                timeout: self

                    .timeout

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::Timeout))

                    .transpose()?,

                client_token: self

                    .client_token

                    .map(|v| match v {

                        crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),

                        crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),

                    })

                    .map(|res| res.map_err(ConstraintViolation::ClientToken))

                    .transpose()?,

                volume_size: self

                    .volume_size

                    .map(|res| res.map_err(ConstraintViolation::VolumeSize))

                    .ok_or(ConstraintViolation::MissingVolumeSize)?,

                tags: self

                    .tags

                    .map(|res| res.map(|v| v.into()).map_err(ConstraintViolation::Tags))

                encrypted: self.encrypted,

                kms_key_arn: self

                    .kms_key_arn

                    .map(|res| res.map_err(ConstraintViolation::KmsKeyArn))

                parent_snapshot_id: self

                    .parent_snapshot_id

                    .map(|res| res.map_err(ConstraintViolation::ParentSnapshotId))

                    .transpose()?,

                description: self

                    .description

                    .map(|res| res.map_err(ConstraintViolation::Description))

    impl ::std::fmt::Debug for Builder {

        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {

            let mut formatter = f.debug_struct("Builder");

            formatter.field("timeout", &self.timeout);

            formatter.field("client_token", &self.client_token);

            formatter.field("volume_size", &self.volume_size);

            formatter.field("tags", &self.tags);

            formatter.field("encrypted", &self.encrypted);

            formatter.field("kms_key_arn", &"*** Sensitive Data Redacted ***");

            formatter.field("parent_snapshot_id", &self.parent_snapshot_id);

            formatter.field("description", &self.description);

            formatter.finish()

        }

    }

/// See [`PutSnapshotBlockInput`](crate::input::PutSnapshotBlockInput).

pub mod put_snapshot_block_input {

        /// `snapshot_id` was not provided but it is required when building `PutSnapshotBlockInput`.

        /// Constraint violation occurred building member `snapshot_id` when building `PutSnapshotBlockInput`.

        /// `block_index` was not provided but it is required when building `PutSnapshotBlockInput`.

        MissingBlockIndex,

        /// Constraint violation occurred building member `block_index` when building `PutSnapshotBlockInput`.

        #[doc(hidden)]

        BlockIndex(crate::model::block_index::ConstraintViolation),

        /// `checksum` was not provided but it is required when building `PutSnapshotBlockInput`.

        MissingChecksum,

        /// Constraint violation occurred building member `checksum` when building `PutSnapshotBlockInput`.

        #[doc(hidden)]

        Checksum(crate::model::checksum::ConstraintViolation),

        /// Constraint violation occurred building member `progress` when building `PutSnapshotBlockInput`.

        Progress(crate::model::progress::ConstraintViolation),

        /// `block_data` was not provided but it is required when building `PutSnapshotBlockInput`.

        MissingBlockData,

        /// `data_length` was not provided but it is required when building `PutSnapshotBlockInput`.

        MissingDataLength,

        /// `checksum_algorithm` was not provided but it is required when building `PutSnapshotBlockInput`.

        MissingChecksumAlgorithm,

        /// Constraint violation occurred building member `checksum_algorithm` when building `PutSnapshotBlockInput`.

        ChecksumAlgorithm(crate::model::checksum_algorithm::ConstraintViolation),

                ConstraintViolation::MissingSnapshotId => write!(f, "`snapshot_id` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::SnapshotId(_) => write!(f, "constraint violation occurred building member `snapshot_id` when building `PutSnapshotBlockInput`"),

                ConstraintViolation::MissingBlockIndex => write!(f, "`block_index` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::BlockIndex(_) => write!(f, "constraint violation occurred building member `block_index` when building `PutSnapshotBlockInput`"),

                ConstraintViolation::MissingChecksum => write!(f, "`checksum` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::Checksum(_) => write!(f, "constraint violation occurred building member `checksum` when building `PutSnapshotBlockInput`"),

                ConstraintViolation::Progress(_) => write!(f, "constraint violation occurred building member `progress` when building `PutSnapshotBlockInput`"),

                ConstraintViolation::MissingBlockData => write!(f, "`block_data` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::MissingDataLength => write!(f, "`data_length` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::MissingChecksumAlgorithm => write!(f, "`checksum_algorithm` was not provided but it is required when building `PutSnapshotBlockInput`"),

                ConstraintViolation::ChecksumAlgorithm(_) => write!(f, "constraint violation occurred building member `checksum_algorithm` when building `PutSnapshotBlockInput`"),