AWS SDK

AWS SDK

rev. d8779bdf94938a194237beaa6a569c9e3849b504

Files changed:

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_server_side_encryption_rule.rs

@@ -1,1 +114,146 @@
   15     15   
    pub apply_server_side_encryption_by_default: ::std::option::Option<crate::types::ServerSideEncryptionByDefault>,
   16     16   
    /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3 Bucket Key.</p><note>
   17     17   
    /// <ul>
   18     18   
    /// <li>
   19     19   
    /// <p><b>General purpose buckets</b> - By default, S3 Bucket Key is not enabled. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html">Amazon S3 Bucket Keys</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   20     20   
    /// <li>
   21     21   
    /// <p><b>Directory buckets</b> - S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p></li>
   22     22   
    /// </ul>
   23     23   
    /// </note>
   24     24   
    pub bucket_key_enabled: ::std::option::Option<bool>,
          25  +
    /// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p><note>
          26  +
    /// <p>Currently, this parameter only supports blocking or unblocking server-side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          27  +
    /// </note>
          28  +
    pub blocked_encryption_types: ::std::option::Option<crate::types::BlockedEncryptionTypes>,
   25     29   
}
   26     30   
impl ServerSideEncryptionRule {
   27     31   
    /// <p>Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.</p>
   28     32   
    pub fn apply_server_side_encryption_by_default(&self) -> ::std::option::Option<&crate::types::ServerSideEncryptionByDefault> {
   29     33   
        self.apply_server_side_encryption_by_default.as_ref()
   30     34   
    }
   31     35   
    /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3 Bucket Key.</p><note>
   32     36   
    /// <ul>
   33     37   
    /// <li>
   34     38   
    /// <p><b>General purpose buckets</b> - By default, S3 Bucket Key is not enabled. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html">Amazon S3 Bucket Keys</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   35     39   
    /// <li>
   36     40   
    /// <p><b>Directory buckets</b> - S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p></li>
   37     41   
    /// </ul>
   38     42   
    /// </note>
   39     43   
    pub fn bucket_key_enabled(&self) -> ::std::option::Option<bool> {
   40     44   
        self.bucket_key_enabled
   41     45   
    }
          46  +
    /// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p><note>
          47  +
    /// <p>Currently, this parameter only supports blocking or unblocking server-side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          48  +
    /// </note>
          49  +
    pub fn blocked_encryption_types(&self) -> ::std::option::Option<&crate::types::BlockedEncryptionTypes> {
          50  +
        self.blocked_encryption_types.as_ref()
          51  +
    }
   42     52   
}
   43     53   
impl ServerSideEncryptionRule {
   44     54   
    /// Creates a new builder-style object to manufacture [`ServerSideEncryptionRule`](crate::types::ServerSideEncryptionRule).
   45     55   
    pub fn builder() -> crate::types::builders::ServerSideEncryptionRuleBuilder {
   46     56   
        crate::types::builders::ServerSideEncryptionRuleBuilder::default()
   47     57   
    }
   48     58   
}
   49     59   
   50     60   
/// A builder for [`ServerSideEncryptionRule`](crate::types::ServerSideEncryptionRule).
   51     61   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   52     62   
#[non_exhaustive]
   53     63   
pub struct ServerSideEncryptionRuleBuilder {
   54     64   
    pub(crate) apply_server_side_encryption_by_default: ::std::option::Option<crate::types::ServerSideEncryptionByDefault>,
   55     65   
    pub(crate) bucket_key_enabled: ::std::option::Option<bool>,
          66  +
    pub(crate) blocked_encryption_types: ::std::option::Option<crate::types::BlockedEncryptionTypes>,
   56     67   
}
   57     68   
impl ServerSideEncryptionRuleBuilder {
   58     69   
    /// <p>Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.</p>
   59     70   
    pub fn apply_server_side_encryption_by_default(mut self, input: crate::types::ServerSideEncryptionByDefault) -> Self {
   60     71   
        self.apply_server_side_encryption_by_default = ::std::option::Option::Some(input);
   61     72   
        self
   62     73   
    }
   63     74   
    /// <p>Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.</p>
   64     75   
    pub fn set_apply_server_side_encryption_by_default(mut self, input: ::std::option::Option<crate::types::ServerSideEncryptionByDefault>) -> Self {
   65     76   
        self.apply_server_side_encryption_by_default = input;
   66     77   
        self
   67     78   
    }
   68     79   
    /// <p>Specifies the default server-side encryption to apply to new objects in the bucket. If a PUT Object request doesn't specify any server-side encryption, this default encryption will be applied.</p>
   69     80   
    pub fn get_apply_server_side_encryption_by_default(&self) -> &::std::option::Option<crate::types::ServerSideEncryptionByDefault> {
   70     81   
        &self.apply_server_side_encryption_by_default
   71     82   
    }
   72     83   
    /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3 Bucket Key.</p><note>
   73     84   
    /// <ul>
   74     85   
    /// <li>
   75     86   
    /// <p><b>General purpose buckets</b> - By default, S3 Bucket Key is not enabled. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html">Amazon S3 Bucket Keys</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   76     87   
    /// <li>
   77     88   
    /// <p><b>Directory buckets</b> - S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p></li>
   78     89   
    /// </ul>
   79     90   
    /// </note>
   80     91   
    pub fn bucket_key_enabled(mut self, input: bool) -> Self {
   81     92   
        self.bucket_key_enabled = ::std::option::Option::Some(input);
   82     93   
        self
   83     94   
    }
   84     95   
    /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3 Bucket Key.</p><note>
   85     96   
    /// <ul>
   86     97   
    /// <li>
   87     98   
    /// <p><b>General purpose buckets</b> - By default, S3 Bucket Key is not enabled. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html">Amazon S3 Bucket Keys</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   88     99   
    /// <li>
   89    100   
    /// <p><b>Directory buckets</b> - S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p></li>
   90    101   
    /// </ul>
   91    102   
    /// </note>
   92    103   
    pub fn set_bucket_key_enabled(mut self, input: ::std::option::Option<bool>) -> Self {
   93    104   
        self.bucket_key_enabled = input;
   94    105   
        self
   95    106   
    }
   96    107   
    /// <p>Specifies whether Amazon S3 should use an S3 Bucket Key with server-side encryption using KMS (SSE-KMS) for new objects in the bucket. Existing objects are not affected. Setting the <code>BucketKeyEnabled</code> element to <code>true</code> causes Amazon S3 to use an S3 Bucket Key.</p><note>
   97    108   
    /// <ul>
   98    109   
    /// <li>
   99    110   
    /// <p><b>General purpose buckets</b> - By default, S3 Bucket Key is not enabled. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/bucket-key.html">Amazon S3 Bucket Keys</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  100    111   
    /// <li>
  101    112   
    /// <p><b>Directory buckets</b> - S3 Bucket Keys are always enabled for <code>GET</code> and <code>PUT</code> operations in a directory bucket and can’t be disabled. S3 Bucket Keys aren't supported, when you copy SSE-KMS encrypted objects from general purpose buckets to directory buckets, from directory buckets to general purpose buckets, or between directory buckets, through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPartCopy.html">UploadPartCopy</a>, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-objects-Batch-Ops">the Copy operation in Batch Operations</a>, or <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-import-job">the import jobs</a>. In this case, Amazon S3 makes a call to KMS every time a copy request is made for a KMS-encrypted object.</p></li>
  102    113   
    /// </ul>
  103    114   
    /// </note>
  104    115   
    pub fn get_bucket_key_enabled(&self) -> &::std::option::Option<bool> {
  105    116   
        &self.bucket_key_enabled
  106    117   
    }
         118  +
    /// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p><note>
         119  +
    /// <p>Currently, this parameter only supports blocking or unblocking server-side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
         120  +
    /// </note>
         121  +
    pub fn blocked_encryption_types(mut self, input: crate::types::BlockedEncryptionTypes) -> Self {
         122  +
        self.blocked_encryption_types = ::std::option::Option::Some(input);
         123  +
        self
         124  +
    }
         125  +
    /// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p><note>
         126  +
    /// <p>Currently, this parameter only supports blocking or unblocking server-side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
         127  +
    /// </note>
         128  +
    pub fn set_blocked_encryption_types(mut self, input: ::std::option::Option<crate::types::BlockedEncryptionTypes>) -> Self {
         129  +
        self.blocked_encryption_types = input;
         130  +
        self
         131  +
    }
         132  +
    /// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p><note>
         133  +
    /// <p>Currently, this parameter only supports blocking or unblocking server-side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
         134  +
    /// </note>
         135  +
    pub fn get_blocked_encryption_types(&self) -> &::std::option::Option<crate::types::BlockedEncryptionTypes> {
         136  +
        &self.blocked_encryption_types
         137  +
    }
  107    138   
    /// Consumes the builder and constructs a [`ServerSideEncryptionRule`](crate::types::ServerSideEncryptionRule).
  108    139   
    pub fn build(self) -> crate::types::ServerSideEncryptionRule {
  109    140   
        crate::types::ServerSideEncryptionRule {
  110    141   
            apply_server_side_encryption_by_default: self.apply_server_side_encryption_by_default,
  111    142   
            bucket_key_enabled: self.bucket_key_enabled,
         143  +
            blocked_encryption_types: self.blocked_encryption_types,
  112    144   
        }
  113    145   
    }
  114    146   
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/_storage_class.rs

@@ -1,1 +181,188 @@
    7      7   
/// upgrade SDK to a future version in which the enum does include a variant for that
    8      8   
/// feature.
    9      9   
///
   10     10   
/// Here is an example of how you can make a match expression forward-compatible:
   11     11   
///
   12     12   
/// ```text
   13     13   
/// # let storageclass = unimplemented!();
   14     14   
/// match storageclass {
   15     15   
///     StorageClass::DeepArchive => { /* ... */ },
   16     16   
///     StorageClass::ExpressOnezone => { /* ... */ },
          17  +
///     StorageClass::FsxOntap => { /* ... */ },
   17     18   
///     StorageClass::FsxOpenzfs => { /* ... */ },
   18     19   
///     StorageClass::Glacier => { /* ... */ },
   19     20   
///     StorageClass::GlacierIr => { /* ... */ },
   20     21   
///     StorageClass::IntelligentTiering => { /* ... */ },
   21     22   
///     StorageClass::OnezoneIa => { /* ... */ },
   22     23   
///     StorageClass::Outposts => { /* ... */ },
   23     24   
///     StorageClass::ReducedRedundancy => { /* ... */ },
   24     25   
///     StorageClass::Snow => { /* ... */ },
   25     26   
///     StorageClass::Standard => { /* ... */ },
   26     27   
///     StorageClass::StandardIa => { /* ... */ },
   27     28   
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
   28     29   
///     _ => { /* ... */ },
   29     30   
/// }
   30     31   
/// ```
   31     32   
/// The above code demonstrates that when `storageclass` represents
   32     33   
/// `NewFeature`, the execution path will lead to the second last match arm,
   33     34   
/// even though the enum does not contain a variant `StorageClass::NewFeature`
   34     35   
/// in the current version of SDK. The reason is that the variable `other`,
   35     36   
/// created by the `@` operator, is bound to
   36     37   
/// `StorageClass::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
   37     38   
/// and calling `as_str` on it yields `"NewFeature"`.
   38     39   
/// This match expression is forward-compatible when executed with a newer
   39     40   
/// version of SDK where the variant `StorageClass::NewFeature` is defined.
   40     41   
/// Specifically, when `storageclass` represents `NewFeature`,
   41     42   
/// the execution path will hit the second last match arm as before by virtue of
   42     43   
/// calling `as_str` on `StorageClass::NewFeature` also yielding `"NewFeature"`.
   43     44   
///
   44     45   
/// Explicitly matching on the `Unknown` variant should
   45     46   
/// be avoided for two reasons:
   46     47   
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
   47     48   
/// - It might inadvertently shadow other intended match arms.
   48     49   
///
   49     50   
#[allow(missing_docs)] // documentation missing in model
   50     51   
#[non_exhaustive]
   51     52   
#[derive(
   52     53   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
   53     54   
)]
   54     55   
pub enum StorageClass {
   55     56   
    #[allow(missing_docs)] // documentation missing in model
   56     57   
    DeepArchive,
   57     58   
    #[allow(missing_docs)] // documentation missing in model
   58     59   
    ExpressOnezone,
   59     60   
    #[allow(missing_docs)] // documentation missing in model
          61  +
    FsxOntap,
          62  +
    #[allow(missing_docs)] // documentation missing in model
   60     63   
    FsxOpenzfs,
   61     64   
    #[allow(missing_docs)] // documentation missing in model
   62     65   
    Glacier,
   63     66   
    #[allow(missing_docs)] // documentation missing in model
   64     67   
    GlacierIr,
   65     68   
    #[allow(missing_docs)] // documentation missing in model
   66     69   
    IntelligentTiering,
   67     70   
    #[allow(missing_docs)] // documentation missing in model
   68     71   
    OnezoneIa,
   69     72   
    #[allow(missing_docs)] // documentation missing in model
   70     73   
    Outposts,
   71     74   
    #[allow(missing_docs)] // documentation missing in model
   72     75   
    ReducedRedundancy,
   73     76   
    #[allow(missing_docs)] // documentation missing in model
   74     77   
    Snow,
   75     78   
    #[allow(missing_docs)] // documentation missing in model
   76     79   
    Standard,
   77     80   
    #[allow(missing_docs)] // documentation missing in model
   78     81   
    StandardIa,
   79     82   
    /// `Unknown` contains new variants that have been added since this code was generated.
   80     83   
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
   81     84   
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
   82     85   
}
   83     86   
impl ::std::convert::From<&str> for StorageClass {
   84     87   
    fn from(s: &str) -> Self {
   85     88   
        match s {
   86     89   
            "DEEP_ARCHIVE" => StorageClass::DeepArchive,
   87     90   
            "EXPRESS_ONEZONE" => StorageClass::ExpressOnezone,
          91  +
            "FSX_ONTAP" => StorageClass::FsxOntap,
   88     92   
            "FSX_OPENZFS" => StorageClass::FsxOpenzfs,
   89     93   
            "GLACIER" => StorageClass::Glacier,
   90     94   
            "GLACIER_IR" => StorageClass::GlacierIr,
   91     95   
            "INTELLIGENT_TIERING" => StorageClass::IntelligentTiering,
   92     96   
            "ONEZONE_IA" => StorageClass::OnezoneIa,
   93     97   
            "OUTPOSTS" => StorageClass::Outposts,
   94     98   
            "REDUCED_REDUNDANCY" => StorageClass::ReducedRedundancy,
   95     99   
            "SNOW" => StorageClass::Snow,
   96    100   
            "STANDARD" => StorageClass::Standard,
   97    101   
            "STANDARD_IA" => StorageClass::StandardIa,
   98    102   
            other => StorageClass::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
   99    103   
        }
  100    104   
    }
  101    105   
}
  102    106   
impl ::std::str::FromStr for StorageClass {
  103    107   
    type Err = ::std::convert::Infallible;
  104    108   
  105    109   
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
  106    110   
        ::std::result::Result::Ok(StorageClass::from(s))
  107    111   
    }
  108    112   
}
  109    113   
impl StorageClass {
  110    114   
    /// Returns the `&str` value of the enum member.
  111    115   
    pub fn as_str(&self) -> &str {
  112    116   
        match self {
  113    117   
            StorageClass::DeepArchive => "DEEP_ARCHIVE",
  114    118   
            StorageClass::ExpressOnezone => "EXPRESS_ONEZONE",
         119  +
            StorageClass::FsxOntap => "FSX_ONTAP",
  115    120   
            StorageClass::FsxOpenzfs => "FSX_OPENZFS",
  116    121   
            StorageClass::Glacier => "GLACIER",
  117    122   
            StorageClass::GlacierIr => "GLACIER_IR",
  118    123   
            StorageClass::IntelligentTiering => "INTELLIGENT_TIERING",
  119    124   
            StorageClass::OnezoneIa => "ONEZONE_IA",
  120    125   
            StorageClass::Outposts => "OUTPOSTS",
  121    126   
            StorageClass::ReducedRedundancy => "REDUCED_REDUNDANCY",
  122    127   
            StorageClass::Snow => "SNOW",
  123    128   
            StorageClass::Standard => "STANDARD",
  124    129   
            StorageClass::StandardIa => "STANDARD_IA",
  125    130   
            StorageClass::Unknown(value) => value.as_str(),
  126    131   
        }
  127    132   
    }
  128    133   
    /// Returns all the `&str` representations of the enum members.
  129    134   
    pub const fn values() -> &'static [&'static str] {
  130    135   
        &[
  131    136   
            "DEEP_ARCHIVE",
  132    137   
            "EXPRESS_ONEZONE",
         138  +
            "FSX_ONTAP",
  133    139   
            "FSX_OPENZFS",
  134    140   
            "GLACIER",
  135    141   
            "GLACIER_IR",
  136    142   
            "INTELLIGENT_TIERING",
  137    143   
            "ONEZONE_IA",
  138    144   
            "OUTPOSTS",
  139    145   
            "REDUCED_REDUNDANCY",
  140    146   
            "SNOW",
  141    147   
            "STANDARD",
  142    148   
            "STANDARD_IA",
  143    149   
        ]
  144    150   
    }
  145    151   
}
  146    152   
impl ::std::convert::AsRef<str> for StorageClass {
  147    153   
    fn as_ref(&self) -> &str {
  148    154   
        self.as_str()
  149    155   
    }
  150    156   
}
  151    157   
impl StorageClass {
  152    158   
    /// Parses the enum value while disallowing unknown variants.
  153    159   
    ///
  154    160   
    /// Unknown variants will result in an error.
  155    161   
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
  156    162   
        match Self::from(value) {
  157    163   
            #[allow(deprecated)]
  158    164   
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
  159    165   
            known => Ok(known),
  160    166   
        }
  161    167   
    }
  162    168   
}
  163    169   
impl ::std::fmt::Display for StorageClass {
  164    170   
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
  165    171   
        match self {
  166    172   
            StorageClass::DeepArchive => write!(f, "DEEP_ARCHIVE"),
  167    173   
            StorageClass::ExpressOnezone => write!(f, "EXPRESS_ONEZONE"),
         174  +
            StorageClass::FsxOntap => write!(f, "FSX_ONTAP"),
  168    175   
            StorageClass::FsxOpenzfs => write!(f, "FSX_OPENZFS"),
  169    176   
            StorageClass::Glacier => write!(f, "GLACIER"),
  170    177   
            StorageClass::GlacierIr => write!(f, "GLACIER_IR"),
  171    178   
            StorageClass::IntelligentTiering => write!(f, "INTELLIGENT_TIERING"),
  172    179   
            StorageClass::OnezoneIa => write!(f, "ONEZONE_IA"),
  173    180   
            StorageClass::Outposts => write!(f, "OUTPOSTS"),
  174    181   
            StorageClass::ReducedRedundancy => write!(f, "REDUCED_REDUNDANCY"),
  175    182   
            StorageClass::Snow => write!(f, "SNOW"),
  176    183   
            StorageClass::Standard => write!(f, "STANDARD"),
  177    184   
            StorageClass::StandardIa => write!(f, "STANDARD_IA"),

tmp-codegen-diff/aws-sdk/sdk/s3/src/types/builders.rs

@@ -1,1 +45,47 @@
    6      6   
pub use crate::types::_create_bucket_configuration::CreateBucketConfigurationBuilder;
    7      7   
    8      8   
pub use crate::types::_metadata_configuration::MetadataConfigurationBuilder;
    9      9   
   10     10   
pub use crate::types::_metadata_table_configuration::MetadataTableConfigurationBuilder;
   11     11   
   12     12   
pub use crate::types::_session_credentials::SessionCredentialsBuilder;
   13     13   
   14     14   
pub use crate::types::_delete::DeleteBuilder;
   15     15   
          16  +
pub use crate::types::_abac_status::AbacStatusBuilder;
          17  +
   16     18   
pub use crate::types::_owner::OwnerBuilder;
   17     19   
   18     20   
pub use crate::types::_analytics_configuration::AnalyticsConfigurationBuilder;
   19     21   
   20     22   
pub use crate::types::_server_side_encryption_configuration::ServerSideEncryptionConfigurationBuilder;
   21     23   
   22     24   
pub use crate::types::_intelligent_tiering_configuration::IntelligentTieringConfigurationBuilder;
   23     25   
   24     26   
pub use crate::types::_inventory_configuration::InventoryConfigurationBuilder;
   25     27
@@ -230,232 +289,293 @@
  250    252   
pub use crate::types::_s3_location::S3LocationBuilder;
  251    253   
  252    254   
pub use crate::types::_stats::StatsBuilder;
  253    255   
  254    256   
pub use crate::types::_progress::ProgressBuilder;
  255    257   
  256    258   
pub use crate::types::_analytics_export_destination::AnalyticsExportDestinationBuilder;
  257    259   
  258    260   
pub use crate::types::_server_side_encryption_by_default::ServerSideEncryptionByDefaultBuilder;
  259    261   
         262  +
pub use crate::types::_blocked_encryption_types::BlockedEncryptionTypesBuilder;
         263  +
  260    264   
pub use crate::types::_inventory_encryption::InventoryEncryptionBuilder;
  261    265   
  262    266   
pub use crate::types::_lifecycle_rule_and_operator::LifecycleRuleAndOperatorBuilder;
  263    267   
  264    268   
pub use crate::types::_transition::TransitionBuilder;
  265    269   
  266    270   
pub use crate::types::_noncurrent_version_transition::NoncurrentVersionTransitionBuilder;
  267    271   
  268    272   
pub use crate::types::_s3_key_filter::S3KeyFilterBuilder;
  269    273

tmp-codegen-diff/aws-sdk/sdk/s3/tests/endpoint_tests.rs

@@ -6008,6008 +6305,6431 @@
 6028   6028   
    let error = _result.expect_err("expected error: Unrecognized S3Express bucket name format. [bad AP format error no session auth]");
 6029   6029   
    assert!(
 6030   6030   
        format!("{:?}", error).contains("Unrecognized S3Express bucket name format."),
 6031   6031   
        "expected error to contain `Unrecognized S3Express bucket name format.` but it was {:?}",
 6032   6032   
        error
 6033   6033   
    );
 6034   6034   
}
 6035   6035   
 6036   6036   
#[::tokio::test]
 6037   6037   
async fn operation_input_test_get_object_178() {
 6038         -
    /* documentation: dual-stack error */
        6038  +
    /* documentation: accelerate error */
 6039   6039   
    /* builtIns: {
 6040   6040   
        "AWS::Region": "us-east-1",
 6041         -
        "AWS::UseDualStack": true
        6041  +
        "AWS::S3::Accelerate": true
 6042   6042   
    } */
 6043   6043   
    /* clientParams: {} */
 6044   6044   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6045   6045   
    let conf = {
 6046   6046   
        #[allow(unused_mut)]
 6047   6047   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6048   6048   
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
 6049         -
        let builder = builder.use_dual_stack(true);
        6049  +
        let builder = builder.accelerate(true);
 6050   6050   
        builder.build()
 6051   6051   
    };
 6052   6052   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6053   6053   
    let _result = dbg!(
 6054   6054   
        client
 6055   6055   
            .get_object()
 6056   6056   
            .set_bucket(::std::option::Option::Some("mybucket--test-ab1--x-s3".to_owned()))
 6057   6057   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6058   6058   
            .send()
 6059   6059   
            .await
 6060   6060   
    );
 6061   6061   
    rcvr.expect_no_request();
 6062         -
    let error = _result.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error]");
        6062  +
    let error = _result.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
 6063   6063   
    assert!(
 6064         -
        format!("{:?}", error).contains("S3Express does not support Dual-stack."),
 6065         -
        "expected error to contain `S3Express does not support Dual-stack.` but it was {:?}",
        6064  +
        format!("{:?}", error).contains("S3Express does not support S3 Accelerate."),
        6065  +
        "expected error to contain `S3Express does not support S3 Accelerate.` but it was {:?}",
 6066   6066   
        error
 6067   6067   
    );
 6068   6068   
}
 6069   6069   
 6070   6070   
#[::tokio::test]
 6071   6071   
async fn operation_input_test_get_object_179() {
 6072         -
    /* documentation: dual-stack error with AP */
        6072  +
    /* documentation: accelerate error with AP */
 6073   6073   
    /* builtIns: {
 6074   6074   
        "AWS::Region": "us-east-1",
 6075         -
        "AWS::UseDualStack": true
        6075  +
        "AWS::S3::Accelerate": true
 6076   6076   
    } */
 6077   6077   
    /* clientParams: {} */
 6078   6078   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6079   6079   
    let conf = {
 6080   6080   
        #[allow(unused_mut)]
 6081   6081   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6082   6082   
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
 6083         -
        let builder = builder.use_dual_stack(true);
        6083  +
        let builder = builder.accelerate(true);
 6084   6084   
        builder.build()
 6085   6085   
    };
 6086   6086   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6087   6087   
    let _result = dbg!(
 6088   6088   
        client
 6089   6089   
            .get_object()
 6090   6090   
            .set_bucket(::std::option::Option::Some("myaccesspoint--test-ab1--xa-s3".to_owned()))
 6091   6091   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6092   6092   
            .send()
 6093   6093   
            .await
 6094   6094   
    );
 6095   6095   
    rcvr.expect_no_request();
 6096         -
    let error = _result.expect_err("expected error: S3Express does not support Dual-stack. [dual-stack error with AP]");
        6096  +
    let error = _result.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
 6097   6097   
    assert!(
 6098         -
        format!("{:?}", error).contains("S3Express does not support Dual-stack."),
 6099         -
        "expected error to contain `S3Express does not support Dual-stack.` but it was {:?}",
        6098  +
        format!("{:?}", error).contains("S3Express does not support S3 Accelerate."),
        6099  +
        "expected error to contain `S3Express does not support S3 Accelerate.` but it was {:?}",
 6100   6100   
        error
 6101   6101   
    );
 6102   6102   
}
 6103   6103   
 6104   6104   
#[::tokio::test]
 6105   6105   
async fn operation_input_test_get_object_180() {
 6106         -
    /* documentation: accelerate error */
        6106  +
    /* documentation: Data plane bucket format error */
 6107   6107   
    /* builtIns: {
 6108         -
        "AWS::Region": "us-east-1",
 6109         -
        "AWS::S3::Accelerate": true
        6108  +
        "AWS::Region": "us-east-1"
 6110   6109   
    } */
 6111   6110   
    /* clientParams: {} */
 6112   6111   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6113   6112   
    let conf = {
 6114   6113   
        #[allow(unused_mut)]
 6115   6114   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6116   6115   
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
 6117         -
        let builder = builder.accelerate(true);
 6118   6116   
        builder.build()
 6119   6117   
    };
 6120   6118   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6121   6119   
    let _result = dbg!(
 6122   6120   
        client
 6123   6121   
            .get_object()
 6124         -
            .set_bucket(::std::option::Option::Some("mybucket--test-ab1--x-s3".to_owned()))
        6122  +
            .set_bucket(::std::option::Option::Some("my.bucket--test-ab1--x-s3".to_owned()))
 6125   6123   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6126   6124   
            .send()
 6127   6125   
            .await
 6128   6126   
    );
 6129   6127   
    rcvr.expect_no_request();
 6130         -
    let error = _result.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error]");
        6128  +
    let error = _result.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
 6131   6129   
    assert!(
 6132         -
        format!("{:?}", error).contains("S3Express does not support S3 Accelerate."),
 6133         -
        "expected error to contain `S3Express does not support S3 Accelerate.` but it was {:?}",
        6130  +
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
        6131  +
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6134   6132   
        error
 6135   6133   
    );
 6136   6134   
}
 6137   6135   
 6138   6136   
#[::tokio::test]
 6139   6137   
async fn operation_input_test_get_object_181() {
 6140         -
    /* documentation: accelerate error with AP */
        6138  +
    /* documentation: Data plane AP format error */
 6141   6139   
    /* builtIns: {
 6142         -
        "AWS::Region": "us-east-1",
 6143         -
        "AWS::S3::Accelerate": true
        6140  +
        "AWS::Region": "us-east-1"
 6144   6141   
    } */
 6145   6142   
    /* clientParams: {} */
 6146   6143   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6147   6144   
    let conf = {
 6148   6145   
        #[allow(unused_mut)]
 6149   6146   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6150   6147   
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
 6151         -
        let builder = builder.accelerate(true);
 6152   6148   
        builder.build()
 6153   6149   
    };
 6154   6150   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6155   6151   
    let _result = dbg!(
 6156   6152   
        client
 6157   6153   
            .get_object()
 6158         -
            .set_bucket(::std::option::Option::Some("myaccesspoint--test-ab1--xa-s3".to_owned()))
        6154  +
            .set_bucket(::std::option::Option::Some("my.myaccesspoint--test-ab1--xa-s3".to_owned()))
 6159   6155   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6160   6156   
            .send()
 6161   6157   
            .await
 6162   6158   
    );
 6163   6159   
    rcvr.expect_no_request();
 6164         -
    let error = _result.expect_err("expected error: S3Express does not support S3 Accelerate. [accelerate error with AP]");
        6160  +
    let error = _result.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
 6165   6161   
    assert!(
 6166         -
        format!("{:?}", error).contains("S3Express does not support S3 Accelerate."),
 6167         -
        "expected error to contain `S3Express does not support S3 Accelerate.` but it was {:?}",
        6162  +
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
        6163  +
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6168   6164   
        error
 6169   6165   
    );
 6170   6166   
}
 6171   6167   
 6172   6168   
#[::tokio::test]
 6173   6169   
async fn operation_input_test_get_object_182() {
 6174         -
    /* documentation: Data plane bucket format error */
        6170  +
    /* documentation: host override data plane bucket error session auth */
 6175   6171   
    /* builtIns: {
 6176         -
        "AWS::Region": "us-east-1"
        6172  +
        "AWS::Region": "us-west-2",
        6173  +
        "SDK::Endpoint": "https://custom.com"
 6177   6174   
    } */
 6178   6175   
    /* clientParams: {} */
 6179   6176   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6180   6177   
    let conf = {
 6181   6178   
        #[allow(unused_mut)]
 6182   6179   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6183         -
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6180  +
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        6181  +
        let builder = builder.endpoint_url("https://custom.com");
 6184   6182   
        builder.build()
 6185   6183   
    };
 6186   6184   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6187   6185   
    let _result = dbg!(
 6188   6186   
        client
 6189   6187   
            .get_object()
 6190         -
            .set_bucket(::std::option::Option::Some("my.bucket--test-ab1--x-s3".to_owned()))
        6188  +
            .set_bucket(::std::option::Option::Some("my.bucket--usw2-az1--x-s3".to_owned()))
 6191   6189   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6192   6190   
            .send()
 6193   6191   
            .await
 6194   6192   
    );
 6195   6193   
    rcvr.expect_no_request();
 6196         -
    let error = _result.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane bucket format error]");
        6194  +
    let error = _result.expect_err(
        6195  +
        "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
        6196  +
    );
 6197   6197   
    assert!(
 6198   6198   
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
 6199   6199   
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6200   6200   
        error
 6201   6201   
    );
 6202   6202   
}
 6203   6203   
 6204   6204   
#[::tokio::test]
 6205   6205   
async fn operation_input_test_get_object_183() {
 6206         -
    /* documentation: Data plane AP format error */
        6206  +
    /* documentation: host override data plane AP error session auth */
 6207   6207   
    /* builtIns: {
 6208         -
        "AWS::Region": "us-east-1"
        6208  +
        "AWS::Region": "us-west-2",
        6209  +
        "SDK::Endpoint": "https://custom.com"
 6209   6210   
    } */
 6210   6211   
    /* clientParams: {} */
 6211   6212   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6212   6213   
    let conf = {
 6213   6214   
        #[allow(unused_mut)]
 6214   6215   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6215         -
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6216  +
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
        6217  +
        let builder = builder.endpoint_url("https://custom.com");
 6216   6218   
        builder.build()
 6217   6219   
    };
 6218   6220   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6219   6221   
    let _result = dbg!(
 6220   6222   
        client
 6221   6223   
            .get_object()
 6222         -
            .set_bucket(::std::option::Option::Some("my.myaccesspoint--test-ab1--xa-s3".to_owned()))
        6224  +
            .set_bucket(::std::option::Option::Some("my.myaccesspoint--usw2-az1--xa-s3".to_owned()))
 6223   6225   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6224   6226   
            .send()
 6225   6227   
            .await
 6226   6228   
    );
 6227   6229   
    rcvr.expect_no_request();
 6228         -
    let error = _result.expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [Data plane AP format error]");
        6230  +
    let error = _result
        6231  +
        .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]");
 6229   6232   
    assert!(
 6230   6233   
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
 6231   6234   
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6232   6235   
        error
 6233   6236   
    );
 6234   6237   
}
 6235   6238   
 6236   6239   
#[::tokio::test]
 6237         -
async fn operation_input_test_get_object_184() {
 6238         -
    /* documentation: host override data plane bucket error session auth */
        6240  +
async fn operation_input_test_list_directory_buckets_184() {
        6241  +
    /* documentation: Control plane without bucket and dualstack */
        6242  +
    /* builtIns: {
        6243  +
        "AWS::Region": "us-east-1",
        6244  +
        "AWS::UseDualStack": true
        6245  +
    } */
        6246  +
    /* clientParams: {} */
        6247  +
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
        6248  +
    let conf = {
        6249  +
        #[allow(unused_mut)]
        6250  +
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
        6251  +
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6252  +
        let builder = builder.use_dual_stack(true);
        6253  +
        builder.build()
        6254  +
    };
        6255  +
    let client = aws_sdk_s3::Client::from_conf(conf);
        6256  +
    let _result = dbg!(client.list_directory_buckets().send().await);
        6257  +
    let req = rcvr.expect_request();
        6258  +
    let uri = req.uri().to_string();
        6259  +
    assert!(
        6260  +
        uri.starts_with("https://s3express-control.dualstack.us-east-1.amazonaws.com"),
        6261  +
        "expected URI to start with `https://s3express-control.dualstack.us-east-1.amazonaws.com` but it was `{}`",
        6262  +
        uri
        6263  +
    );
        6264  +
}
        6265  +
        6266  +
#[::tokio::test]
        6267  +
async fn operation_input_test_list_directory_buckets_185() {
        6268  +
    /* documentation: Control plane without bucket, fips and dualstack */
        6269  +
    /* builtIns: {
        6270  +
        "AWS::Region": "us-east-1",
        6271  +
        "AWS::UseFIPS": true,
        6272  +
        "AWS::UseDualStack": true
        6273  +
    } */
        6274  +
    /* clientParams: {} */
        6275  +
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
        6276  +
    let conf = {
        6277  +
        #[allow(unused_mut)]
        6278  +
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
        6279  +
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6280  +
        let builder = builder.use_fips(true);
        6281  +
        let builder = builder.use_dual_stack(true);
        6282  +
        builder.build()
        6283  +
    };
        6284  +
    let client = aws_sdk_s3::Client::from_conf(conf);
        6285  +
    let _result = dbg!(client.list_directory_buckets().send().await);
        6286  +
    let req = rcvr.expect_request();
        6287  +
    let uri = req.uri().to_string();
        6288  +
    assert!(
        6289  +
        uri.starts_with("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com"),
        6290  +
        "expected URI to start with `https://s3express-control-fips.dualstack.us-east-1.amazonaws.com` but it was `{}`",
        6291  +
        uri
        6292  +
    );
        6293  +
}
        6294  +
        6295  +
#[::tokio::test]
        6296  +
async fn operation_input_test_get_object_186() {
        6297  +
    /* documentation: Data Plane with short AZ and dualstack */
 6239   6298   
    /* builtIns: {
 6240   6299   
        "AWS::Region": "us-west-2",
 6241         -
        "SDK::Endpoint": "https://custom.com"
        6300  +
        "AWS::UseDualStack": true
 6242   6301   
    } */
 6243   6302   
    /* clientParams: {} */
 6244   6303   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6245   6304   
    let conf = {
 6246   6305   
        #[allow(unused_mut)]
 6247   6306   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6248   6307   
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
 6249         -
        let builder = builder.endpoint_url("https://custom.com");
        6308  +
        let builder = builder.use_dual_stack(true);
 6250   6309   
        builder.build()
 6251   6310   
    };
 6252   6311   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6253   6312   
    let _result = dbg!(
 6254   6313   
        client
 6255   6314   
            .get_object()
 6256         -
            .set_bucket(::std::option::Option::Some("my.bucket--usw2-az1--x-s3".to_owned()))
        6315  +
            .set_bucket(::std::option::Option::Some("mybucket--usw2-az1--x-s3".to_owned()))
 6257   6316   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6258   6317   
            .send()
 6259   6318   
            .await
 6260   6319   
    );
 6261         -
    rcvr.expect_no_request();
 6262         -
    let error = _result.expect_err(
 6263         -
        "expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane bucket error session auth]",
 6264         -
    );
        6320  +
    let req = rcvr.expect_request();
        6321  +
    let uri = req.uri().to_string();
 6265   6322   
    assert!(
 6266         -
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
 6267         -
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6268         -
        error
        6323  +
        uri.starts_with("https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com"),
        6324  +
        "expected URI to start with `https://mybucket--usw2-az1--x-s3.s3express-usw2-az1.dualstack.us-west-2.amazonaws.com` but it was `{}`",
        6325  +
        uri
 6269   6326   
    );
 6270   6327   
}
 6271   6328   
 6272   6329   
#[::tokio::test]
 6273         -
async fn operation_input_test_get_object_185() {
 6274         -
    /* documentation: host override data plane AP error session auth */
        6330  +
async fn operation_input_test_get_object_187() {
        6331  +
    /* documentation: Data Plane with short AZ and FIPS with dualstack */
 6275   6332   
    /* builtIns: {
 6276   6333   
        "AWS::Region": "us-west-2",
 6277         -
        "SDK::Endpoint": "https://custom.com"
        6334  +
        "AWS::UseFIPS": true,
        6335  +
        "AWS::UseDualStack": true
 6278   6336   
    } */
 6279   6337   
    /* clientParams: {} */
 6280   6338   
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
 6281   6339   
    let conf = {
 6282   6340   
        #[allow(unused_mut)]
 6283   6341   
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
 6284   6342   
        let builder = builder.region(::aws_types::region::Region::new("us-west-2"));
 6285         -
        let builder = builder.endpoint_url("https://custom.com");
        6343  +
        let builder = builder.use_fips(true);
        6344  +
        let builder = builder.use_dual_stack(true);
 6286   6345   
        builder.build()
 6287   6346   
    };
 6288   6347   
    let client = aws_sdk_s3::Client::from_conf(conf);
 6289   6348   
    let _result = dbg!(
 6290   6349   
        client
 6291   6350   
            .get_object()
 6292         -
            .set_bucket(::std::option::Option::Some("my.myaccesspoint--usw2-az1--xa-s3".to_owned()))
        6351  +
            .set_bucket(::std::option::Option::Some("mybucket--usw2-az1--x-s3".to_owned()))
 6293   6352   
            .set_key(::std::option::Option::Some("key".to_owned()))
 6294   6353   
            .send()
 6295   6354   
            .await
 6296   6355   
    );
 6297         -
    rcvr.expect_no_request();
 6298         -
    let error = _result
 6299         -
        .expect_err("expected error: S3Express bucket name is not a valid virtual hostable name. [host override data plane AP error session auth]");
        6356  +
    let req = rcvr.expect_request();
        6357  +
    let uri = req.uri().to_string();
 6300   6358   
    assert!(
 6301         -
        format!("{:?}", error).contains("S3Express bucket name is not a valid virtual hostable name."),
 6302         -
        "expected error to contain `S3Express bucket name is not a valid virtual hostable name.` but it was {:?}",
 6303         -
        error
        6359  +
        uri.starts_with("https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com"),
        6360  +
        "expected URI to start with `https://mybucket--usw2-az1--x-s3.s3express-fips-usw2-az1.dualstack.us-west-2.amazonaws.com` but it was `{}`",
        6361  +
        uri
        6362  +
    );
        6363  +
}
        6364  +
        6365  +
#[::tokio::test]
        6366  +
async fn operation_input_test_create_bucket_188() {
        6367  +
    /* documentation: Control plane and FIPS with dualstack */
        6368  +
    /* builtIns: {
        6369  +
        "AWS::Region": "us-east-1",
        6370  +
        "AWS::UseFIPS": true,
        6371  +
        "AWS::UseDualStack": true
        6372  +
    } */
        6373  +
    /* clientParams: {} */
        6374  +
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
        6375  +
    let conf = {
        6376  +
        #[allow(unused_mut)]
        6377  +
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
        6378  +
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6379  +
        let builder = builder.use_fips(true);
        6380  +
        let builder = builder.use_dual_stack(true);
        6381  +
        builder.build()
        6382  +
    };
        6383  +
    let client = aws_sdk_s3::Client::from_conf(conf);
        6384  +
    let _result = dbg!(
        6385  +
        client
        6386  +
            .create_bucket()
        6387  +
            .set_bucket(::std::option::Option::Some("mybucket--test-ab1--x-s3".to_owned()))
        6388  +
            .send()
        6389  +
            .await
        6390  +
    );
        6391  +
    let req = rcvr.expect_request();
        6392  +
    let uri = req.uri().to_string();
        6393  +
    assert!(
        6394  +
        uri.starts_with("https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3"),
        6395  +
        "expected URI to start with `https://s3express-control-fips.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3` but it was `{}`",
        6396  +
        uri
        6397  +
    );
        6398  +
}
        6399  +
        6400  +
#[::tokio::test]
        6401  +
async fn operation_input_test_create_bucket_189() {
        6402  +
    /* documentation: Control plane with dualstack and bucket */
        6403  +
    /* builtIns: {
        6404  +
        "AWS::Region": "us-east-1",
        6405  +
        "AWS::UseDualStack": true
        6406  +
    } */
        6407  +
    /* clientParams: {} */
        6408  +
    let (http_client, rcvr) = ::aws_smithy_http_client::test_util::capture_request(None);
        6409  +
    let conf = {
        6410  +
        #[allow(unused_mut)]
        6411  +
        let mut builder = aws_sdk_s3::Config::builder().with_test_defaults().http_client(http_client);
        6412  +
        let builder = builder.region(::aws_types::region::Region::new("us-east-1"));
        6413  +
        let builder = builder.use_dual_stack(true);
        6414  +
        builder.build()
        6415  +
    };
        6416  +
    let client = aws_sdk_s3::Client::from_conf(conf);
        6417  +
    let _result = dbg!(
        6418  +
        client
        6419  +
            .create_bucket()
        6420  +
            .set_bucket(::std::option::Option::Some("mybucket--test-ab1--x-s3".to_owned()))
        6421  +
            .send()
        6422  +
            .await
        6423  +
    );
        6424  +
    let req = rcvr.expect_request();
        6425  +
    let uri = req.uri().to_string();
        6426  +
    assert!(
        6427  +
        uri.starts_with("https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3"),
        6428  +
        "expected URI to start with `https://s3express-control.dualstack.us-east-1.amazonaws.com/mybucket--test-ab1--x-s3` but it was `{}`",
        6429  +
        uri
 6304   6430   
    );
 6305   6431   
}

tmp-codegen-diff/aws-sdk/sdk/s3control/src/endpoint_lib/arn.rs

@@ -1,1 +42,42 @@
    2      2   
/*
    3      3   
 *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 *  SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
use crate::endpoint_lib::diagnostic::DiagnosticCollector;
    8      8   
use std::borrow::Cow;
    9      9   
use std::error::Error;
   10     10   
use std::fmt::{Display, Formatter};
   11     11   
   12         -
#[derive(Debug, Eq, PartialEq)]
          12  +
#[derive(Debug, Eq, PartialEq, Clone, Default)]
   13     13   
pub(crate) struct Arn<'a> {
   14     14   
    partition: &'a str,
   15     15   
    service: &'a str,
   16     16   
    region: &'a str,
   17     17   
    account_id: &'a str,
   18     18   
    resource_id: Vec<&'a str>,
   19     19   
}
   20     20   
   21     21   
#[allow(unused)]
   22     22   
impl<'a> Arn<'a> {

tmp-codegen-diff/aws-sdk/sdk/s3control/src/endpoint_lib/diagnostic.rs

@@ -7,7 +45,46 @@
   27     27   
    pub(crate) fn capture<T, E: Into<Box<dyn Error + Send + Sync>>>(&mut self, err: Result<T, E>) -> Option<T> {
   28     28   
        match err {
   29     29   
            Ok(res) => Some(res),
   30     30   
            Err(e) => {
   31     31   
                self.report_error(e);
   32     32   
                None
   33     33   
            }
   34     34   
        }
   35     35   
    }
   36     36   
          37  +
    #[allow(dead_code)]
   37     38   
    pub(crate) fn take_last_error(&mut self) -> Option<Box<dyn Error + Send + Sync>> {
   38     39   
        self.last_error.take()
   39     40   
    }
   40     41   
   41     42   
    /// Create a new diagnostic collector
   42     43   
    pub(crate) fn new() -> Self {
   43     44   
        Self { last_error: None }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/aws-sdk/sdk/s3control/src/endpoint_lib/parse_url.rs

@@ -1,1 +47,57 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 *  Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 *  SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
use crate::endpoint_lib::diagnostic::DiagnosticCollector;
    8      8   
use http_1x::Uri;
    9      9   
use url::{Host, Url as ParsedUrl};
   10     10   
   11         -
#[derive(PartialEq, Debug)]
          11  +
#[derive(PartialEq, Debug, Clone)]
   12     12   
pub(crate) struct Url<'a> {
   13     13   
    uri: Uri,
   14     14   
    url: ParsedUrl,
   15     15   
    raw: &'a str,
   16     16   
}
   17     17   
          18  +
impl Default for Url<'_> {
          19  +
    fn default() -> Self {
          20  +
        Self {
          21  +
            uri: Uri::from_static("https://localhost"),
          22  +
            url: ParsedUrl::parse("https://localhost").unwrap(),
          23  +
            raw: "https://localhost",
          24  +
        }
          25  +
    }
          26  +
}
          27  +
   18     28   
// individual methods on parse_url might not be used (although the [`parse_url`] itself _MUST_ be used
   19     29   
// since stdlib functions are pulled into crate lazily)
   20     30   
#[allow(unused)]
   21     31   
impl Url<'_> {
   22     32   
    pub(crate) fn is_ip(&self) -> bool {
   23     33   
        matches!(self.url.host(), Some(Host::Ipv4(_) | Host::Ipv6(_)))
   24     34   
    }
   25     35   
    pub(crate) fn scheme(&self) -> &str {
   26     36   
        self.url.scheme()
   27     37   
    }

tmp-codegen-diff/aws-sdk/sdk/s3control/src/endpoint_lib/partition.rs

@@ -3,3 +62,63 @@
   23     23   
    partitions: Vec<PartitionMetadata>,
   24     24   
}
   25     25   
   26     26   
impl PartitionResolver {
   27     27   
    pub(crate) fn from_partitions(partitions: Vec<PartitionMetadata>) -> Self {
   28     28   
        Self { partitions }
   29     29   
    }
   30     30   
}
   31     31   
   32     32   
/// Partition result returned from partition resolver
          33  +
#[derive(Debug, Default, Clone)]
   33     34   
pub(crate) struct Partition<'a> {
   34     35   
    name: &'a str,
   35     36   
    dns_suffix: &'a str,
   36     37   
    dual_stack_dns_suffix: &'a str,
   37     38   
    supports_fips: bool,
   38     39   
    supports_dual_stack: bool,
   39     40   
    implicit_global_region: &'a str,
   40     41   
}
   41     42   
   42     43   
#[allow(unused)]

tmp-codegen-diff/aws-sdk/sdk/signin/src/endpoint_lib/diagnostic.rs

@@ -7,7 +45,46 @@
   27     27   
    pub(crate) fn capture<T, E: Into<Box<dyn Error + Send + Sync>>>(&mut self, err: Result<T, E>) -> Option<T> {
   28     28   
        match err {
   29     29   
            Ok(res) => Some(res),
   30     30   
            Err(e) => {
   31     31   
                self.report_error(e);
   32     32   
                None
   33     33   
            }
   34     34   
        }
   35     35   
    }
   36     36   
          37  +
    #[allow(dead_code)]
   37     38   
    pub(crate) fn take_last_error(&mut self) -> Option<Box<dyn Error + Send + Sync>> {
   38     39   
        self.last_error.take()
   39     40   
    }
   40     41   
   41     42   
    /// Create a new diagnostic collector
   42     43   
    pub(crate) fn new() -> Self {
   43     44   
        Self { last_error: None }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/aws-sdk/sdk/signin/src/endpoint_lib/partition.rs

@@ -3,3 +62,63 @@
   23     23   
    partitions: Vec<PartitionMetadata>,
   24     24   
}
   25     25   
   26     26   
impl PartitionResolver {
   27     27   
    pub(crate) fn from_partitions(partitions: Vec<PartitionMetadata>) -> Self {
   28     28   
        Self { partitions }
   29     29   
    }
   30     30   
}
   31     31   
   32     32   
/// Partition result returned from partition resolver
          33  +
#[derive(Debug, Default, Clone)]
   33     34   
pub(crate) struct Partition<'a> {
   34     35   
    name: &'a str,
   35     36   
    dns_suffix: &'a str,
   36     37   
    dual_stack_dns_suffix: &'a str,
   37     38   
    supports_fips: bool,
   38     39   
    supports_dual_stack: bool,
   39     40   
    implicit_global_region: &'a str,
   40     41   
}
   41     42   
   42     43   
#[allow(unused)]

tmp-codegen-diff/aws-sdk/sdk/sso/src/endpoint_lib/diagnostic.rs

@@ -7,7 +45,46 @@
   27     27   
    pub(crate) fn capture<T, E: Into<Box<dyn Error + Send + Sync>>>(&mut self, err: Result<T, E>) -> Option<T> {
   28     28   
        match err {
   29     29   
            Ok(res) => Some(res),
   30     30   
            Err(e) => {
   31     31   
                self.report_error(e);
   32     32   
                None
   33     33   
            }
   34     34   
        }
   35     35   
    }
   36     36   
          37  +
    #[allow(dead_code)]
   37     38   
    pub(crate) fn take_last_error(&mut self) -> Option<Box<dyn Error + Send + Sync>> {
   38     39   
        self.last_error.take()
   39     40   
    }
   40     41   
   41     42   
    /// Create a new diagnostic collector
   42     43   
    pub(crate) fn new() -> Self {
   43     44   
        Self { last_error: None }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/aws-sdk/sdk/sso/src/endpoint_lib/partition.rs

@@ -3,3 +62,63 @@
   23     23   
    partitions: Vec<PartitionMetadata>,
   24     24   
}
   25     25   
   26     26   
impl PartitionResolver {
   27     27   
    pub(crate) fn from_partitions(partitions: Vec<PartitionMetadata>) -> Self {
   28     28   
        Self { partitions }
   29     29   
    }
   30     30   
}
   31     31   
   32     32   
/// Partition result returned from partition resolver
          33  +
#[derive(Debug, Default, Clone)]
   33     34   
pub(crate) struct Partition<'a> {
   34     35   
    name: &'a str,
   35     36   
    dns_suffix: &'a str,
   36     37   
    dual_stack_dns_suffix: &'a str,
   37     38   
    supports_fips: bool,
   38     39   
    supports_dual_stack: bool,
   39     40   
    implicit_global_region: &'a str,
   40     41   
}
   41     42   
   42     43   
#[allow(unused)]

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/endpoint_lib/diagnostic.rs

@@ -7,7 +45,46 @@
   27     27   
    pub(crate) fn capture<T, E: Into<Box<dyn Error + Send + Sync>>>(&mut self, err: Result<T, E>) -> Option<T> {
   28     28   
        match err {
   29     29   
            Ok(res) => Some(res),
   30     30   
            Err(e) => {
   31     31   
                self.report_error(e);
   32     32   
                None
   33     33   
            }
   34     34   
        }
   35     35   
    }
   36     36   
          37  +
    #[allow(dead_code)]
   37     38   
    pub(crate) fn take_last_error(&mut self) -> Option<Box<dyn Error + Send + Sync>> {
   38     39   
        self.last_error.take()
   39     40   
    }
   40     41   
   41     42   
    /// Create a new diagnostic collector
   42     43   
    pub(crate) fn new() -> Self {
   43     44   
        Self { last_error: None }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/aws-sdk/sdk/ssooidc/src/endpoint_lib/partition.rs

@@ -3,3 +62,63 @@
   23     23   
    partitions: Vec<PartitionMetadata>,
   24     24   
}
   25     25   
   26     26   
impl PartitionResolver {
   27     27   
    pub(crate) fn from_partitions(partitions: Vec<PartitionMetadata>) -> Self {
   28     28   
        Self { partitions }
   29     29   
    }
   30     30   
}
   31     31   
   32     32   
/// Partition result returned from partition resolver
          33  +
#[derive(Debug, Default, Clone)]
   33     34   
pub(crate) struct Partition<'a> {
   34     35   
    name: &'a str,
   35     36   
    dns_suffix: &'a str,
   36     37   
    dual_stack_dns_suffix: &'a str,
   37     38   
    supports_fips: bool,
   38     39   
    supports_dual_stack: bool,
   39     40   
    implicit_global_region: &'a str,
   40     41   
}
   41     42   
   42     43   
#[allow(unused)]

tmp-codegen-diff/aws-sdk/sdk/sts/src/endpoint_lib/diagnostic.rs

@@ -7,7 +45,46 @@
   27     27   
    pub(crate) fn capture<T, E: Into<Box<dyn Error + Send + Sync>>>(&mut self, err: Result<T, E>) -> Option<T> {
   28     28   
        match err {
   29     29   
            Ok(res) => Some(res),
   30     30   
            Err(e) => {
   31     31   
                self.report_error(e);
   32     32   
                None
   33     33   
            }
   34     34   
        }
   35     35   
    }
   36     36   
          37  +
    #[allow(dead_code)]
   37     38   
    pub(crate) fn take_last_error(&mut self) -> Option<Box<dyn Error + Send + Sync>> {
   38     39   
        self.last_error.take()
   39     40   
    }
   40     41   
   41     42   
    /// Create a new diagnostic collector
   42     43   
    pub(crate) fn new() -> Self {
   43     44   
        Self { last_error: None }
   44     45   
    }
   45     46   
}

tmp-codegen-diff/aws-sdk/sdk/sts/src/endpoint_lib/partition.rs

@@ -3,3 +62,63 @@
   23     23   
    partitions: Vec<PartitionMetadata>,
   24     24   
}
   25     25   
   26     26   
impl PartitionResolver {
   27     27   
    pub(crate) fn from_partitions(partitions: Vec<PartitionMetadata>) -> Self {
   28     28   
        Self { partitions }
   29     29   
    }
   30     30   
}
   31     31   
   32     32   
/// Partition result returned from partition resolver
          33  +
#[derive(Debug, Default, Clone)]
   33     34   
pub(crate) struct Partition<'a> {
   34     35   
    name: &'a str,
   35     36   
    dns_suffix: &'a str,
   36     37   
    dual_stack_dns_suffix: &'a str,
   37     38   
    supports_fips: bool,
   38     39   
    supports_dual_stack: bool,
   39     40   
    implicit_global_region: &'a str,
   40     41   
}
   41     42   
   42     43   
#[allow(unused)]