AWS SDK

AWS SDK

rev. df5c6963ef84701dba433bee7c3177286b57d59a

Files changed:

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

@@ -86,86 +146,148 @@
  106    106   
/// </ul></li>
  107    107   
/// </ul>
  108    108   
/// </dd>
  109    109   
/// </dl>
  110    110   
/// <p>The following operations are related to <code>RestoreObject</code>:</p>
  111    111   
/// <ul>
  112    112   
/// <li>
  113    113   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html">PutBucketLifecycleConfiguration</a></p></li>
  114    114   
/// <li>
  115    115   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketNotificationConfiguration.html">GetBucketNotificationConfiguration</a></p></li>
  116         -
/// </ul>
         116  +
/// </ul><important>
         117  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
         118  +
/// </important>
  117    119   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
  118    120   
pub struct RestoreObjectFluentBuilder {
  119    121   
    handle: ::std::sync::Arc<crate::client::Handle>,
  120    122   
    inner: crate::operation::restore_object::builders::RestoreObjectInputBuilder,
  121    123   
    config_override: ::std::option::Option<crate::config::Builder>,
  122    124   
}
  123    125   
impl
  124    126   
    crate::client::customize::internal::CustomizableSend<
  125    127   
        crate::operation::restore_object::RestoreObjectOutput,
  126    128   
        crate::operation::restore_object::RestoreObjectError,

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

@@ -60,60 +120,122 @@
   80     80   
/// </dd>
   81     81   
/// </dl>
   82     82   
/// <p>The following operations are related to <code>SelectObjectContent</code>:</p>
   83     83   
/// <ul>
   84     84   
/// <li>
   85     85   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html">GetObject</a></p></li>
   86     86   
/// <li>
   87     87   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html">GetBucketLifecycleConfiguration</a></p></li>
   88     88   
/// <li>
   89     89   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html">PutBucketLifecycleConfiguration</a></p></li>
   90         -
/// </ul>
          90  +
/// </ul><important>
          91  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
          92  +
/// </important>
   91     93   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
   92     94   
pub struct SelectObjectContentFluentBuilder {
   93     95   
    handle: ::std::sync::Arc<crate::client::Handle>,
   94     96   
    inner: crate::operation::select_object_content::builders::SelectObjectContentInputBuilder,
   95     97   
    config_override: ::std::option::Option<crate::config::Builder>,
   96     98   
}
   97     99   
impl
   98    100   
    crate::client::customize::internal::CustomizableSend<
   99    101   
        crate::operation::select_object_content::SelectObjectContentOutput,
  100    102   
        crate::operation::select_object_content::SelectObjectContentError,

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

@@ -33,33 +93,95 @@
   53     53   
/// <p>The following operations are related to <code>UpdateBucketMetadataInventoryTableConfiguration</code>:</p>
   54     54   
/// <ul>
   55     55   
/// <li>
   56     56   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucketMetadataConfiguration.html">CreateBucketMetadataConfiguration</a></p></li>
   57     57   
/// <li>
   58     58   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketMetadataConfiguration.html">DeleteBucketMetadataConfiguration</a></p></li>
   59     59   
/// <li>
   60     60   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketMetadataConfiguration.html">GetBucketMetadataConfiguration</a></p></li>
   61     61   
/// <li>
   62     62   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateBucketMetadataJournalTableConfiguration.html">UpdateBucketMetadataJournalTableConfiguration</a></p></li>
   63         -
/// </ul>
          63  +
/// </ul><important>
          64  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
          65  +
/// </important>
   64     66   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
   65     67   
pub struct UpdateBucketMetadataInventoryTableConfigurationFluentBuilder {
   66     68   
    handle: ::std::sync::Arc<crate::client::Handle>,
   67     69   
    inner:
   68     70   
        crate::operation::update_bucket_metadata_inventory_table_configuration::builders::UpdateBucketMetadataInventoryTableConfigurationInputBuilder,
   69     71   
    config_override: ::std::option::Option<crate::config::Builder>,
   70     72   
}
   71     73   
impl
   72     74   
    crate::client::customize::internal::CustomizableSend<
   73     75   
        crate::operation::update_bucket_metadata_inventory_table_configuration::UpdateBucketMetadataInventoryTableConfigurationOutput,

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

@@ -14,14 +74,76 @@
   34     34   
/// <p>The following operations are related to <code>UpdateBucketMetadataJournalTableConfiguration</code>:</p>
   35     35   
/// <ul>
   36     36   
/// <li>
   37     37   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateBucketMetadataConfiguration.html">CreateBucketMetadataConfiguration</a></p></li>
   38     38   
/// <li>
   39     39   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketMetadataConfiguration.html">DeleteBucketMetadataConfiguration</a></p></li>
   40     40   
/// <li>
   41     41   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketMetadataConfiguration.html">GetBucketMetadataConfiguration</a></p></li>
   42     42   
/// <li>
   43     43   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UpdateBucketMetadataInventoryTableConfiguration.html">UpdateBucketMetadataInventoryTableConfiguration</a></p></li>
   44         -
/// </ul>
          44  +
/// </ul><important>
          45  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
          46  +
/// </important>
   45     47   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
   46     48   
pub struct UpdateBucketMetadataJournalTableConfigurationFluentBuilder {
   47     49   
    handle: ::std::sync::Arc<crate::client::Handle>,
   48     50   
    inner: crate::operation::update_bucket_metadata_journal_table_configuration::builders::UpdateBucketMetadataJournalTableConfigurationInputBuilder,
   49     51   
    config_override: ::std::option::Option<crate::config::Builder>,
   50     52   
}
   51     53   
impl
   52     54   
    crate::client::customize::internal::CustomizableSend<
   53     55   
        crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationOutput,
   54     56   
        crate::operation::update_bucket_metadata_journal_table_configuration::UpdateBucketMetadataJournalTableConfigurationError,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/upload_part/_upload_part_output.rs

@@ -1,1 +98,98 @@
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
    5      5   
pub struct UploadPartOutput {
    6      6   
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
    7      7   
    /// <p>When accessing data stored in Amazon FSx file systems using S3 access points, the only valid server side encryption option is <code>aws:fsx</code>.</p>
    8      8   
    /// </note>
    9      9   
    pub server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
   10     10   
    /// <p>Entity tag for the uploaded object.</p>
   11     11   
    pub e_tag: ::std::option::Option<::std::string::String>,
   12         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          12  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   13     13   
    pub checksum_crc32: ::std::option::Option<::std::string::String>,
   14     14   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   15     15   
    pub checksum_crc32_c: ::std::option::Option<::std::string::String>,
   16     16   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   17     17   
    pub checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
   18         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          18  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   19     19   
    pub checksum_sha1: ::std::option::Option<::std::string::String>,
   20         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          20  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   21     21   
    pub checksum_sha256: ::std::option::Option<::std::string::String>,
   22     22   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to confirm the encryption algorithm that's used.</p><note>
   23     23   
    /// <p>This functionality is not supported for directory buckets.</p>
   24     24   
    /// </note>
   25     25   
    pub sse_customer_algorithm: ::std::option::Option<::std::string::String>,
   26     26   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide the round-trip message integrity verification of the customer-provided encryption key.</p><note>
   27     27   
    /// <p>This functionality is not supported for directory buckets.</p>
   28     28   
    /// </note>
   29     29   
    pub sse_customer_key_md5: ::std::option::Option<::std::string::String>,
   30     30   
    /// <p>If present, indicates the ID of the KMS key that was used for object encryption.</p>
   31     31   
    pub ssekms_key_id: ::std::option::Option<::std::string::String>,
   32     32   
    /// <p>Indicates whether the multipart upload uses an S3 Bucket Key for server-side encryption with Key Management Service (KMS) keys (SSE-KMS).</p>
   33     33   
    pub bucket_key_enabled: ::std::option::Option<bool>,
   34     34   
    /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
   35     35   
    /// <p>This functionality is not supported for directory buckets.</p>
   36     36   
    /// </note>
   37     37   
    pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
   38     38   
    _extended_request_id: Option<String>,
   39     39   
    _request_id: Option<String>,
   40     40   
}
   41     41   
impl UploadPartOutput {
   42     42   
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
   43     43   
    /// <p>When accessing data stored in Amazon FSx file systems using S3 access points, the only valid server side encryption option is <code>aws:fsx</code>.</p>
   44     44   
    /// </note>
   45     45   
    pub fn server_side_encryption(&self) -> ::std::option::Option<&crate::types::ServerSideEncryption> {
   46     46   
        self.server_side_encryption.as_ref()
   47     47   
    }
   48     48   
    /// <p>Entity tag for the uploaded object.</p>
   49     49   
    pub fn e_tag(&self) -> ::std::option::Option<&str> {
   50     50   
        self.e_tag.as_deref()
   51     51   
    }
   52         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          52  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   53     53   
    pub fn checksum_crc32(&self) -> ::std::option::Option<&str> {
   54     54   
        self.checksum_crc32.as_deref()
   55     55   
    }
   56     56   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   57     57   
    pub fn checksum_crc32_c(&self) -> ::std::option::Option<&str> {
   58     58   
        self.checksum_crc32_c.as_deref()
   59     59   
    }
   60     60   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   61     61   
    pub fn checksum_crc64_nvme(&self) -> ::std::option::Option<&str> {
   62     62   
        self.checksum_crc64_nvme.as_deref()
   63     63   
    }
   64         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          64  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   65     65   
    pub fn checksum_sha1(&self) -> ::std::option::Option<&str> {
   66     66   
        self.checksum_sha1.as_deref()
   67     67   
    }
   68         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          68  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   69     69   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   70     70   
        self.checksum_sha256.as_deref()
   71     71   
    }
   72     72   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to confirm the encryption algorithm that's used.</p><note>
   73     73   
    /// <p>This functionality is not supported for directory buckets.</p>
   74     74   
    /// </note>
   75     75   
    pub fn sse_customer_algorithm(&self) -> ::std::option::Option<&str> {
   76     76   
        self.sse_customer_algorithm.as_deref()
   77     77   
    }
   78     78   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide the round-trip message integrity verification of the customer-provided encryption key.</p><note>
@@ -160,160 +286,286 @@
  180    180   
    }
  181    181   
    /// <p>Entity tag for the uploaded object.</p>
  182    182   
    pub fn set_e_tag(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  183    183   
        self.e_tag = input;
  184    184   
        self
  185    185   
    }
  186    186   
    /// <p>Entity tag for the uploaded object.</p>
  187    187   
    pub fn get_e_tag(&self) -> &::std::option::Option<::std::string::String> {
  188    188   
        &self.e_tag
  189    189   
    }
  190         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         190  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  191    191   
    pub fn checksum_crc32(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  192    192   
        self.checksum_crc32 = ::std::option::Option::Some(input.into());
  193    193   
        self
  194    194   
    }
  195         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         195  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  196    196   
    pub fn set_checksum_crc32(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  197    197   
        self.checksum_crc32 = input;
  198    198   
        self
  199    199   
    }
  200         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         200  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  201    201   
    pub fn get_checksum_crc32(&self) -> &::std::option::Option<::std::string::String> {
  202    202   
        &self.checksum_crc32
  203    203   
    }
  204    204   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  205    205   
    pub fn checksum_crc32_c(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  206    206   
        self.checksum_crc32_c = ::std::option::Option::Some(input.into());
  207    207   
        self
  208    208   
    }
  209    209   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  210    210   
    pub fn set_checksum_crc32_c(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  211    211   
        self.checksum_crc32_c = input;
  212    212   
        self
  213    213   
    }
  214    214   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  215    215   
    pub fn get_checksum_crc32_c(&self) -> &::std::option::Option<::std::string::String> {
  216    216   
        &self.checksum_crc32_c
  217    217   
    }
  218    218   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  219    219   
    pub fn checksum_crc64_nvme(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  220    220   
        self.checksum_crc64_nvme = ::std::option::Option::Some(input.into());
  221    221   
        self
  222    222   
    }
  223    223   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  224    224   
    pub fn set_checksum_crc64_nvme(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  225    225   
        self.checksum_crc64_nvme = input;
  226    226   
        self
  227    227   
    }
  228    228   
    /// <p>This header can be used as a data integrity check to verify that the data received is the same data that was originally sent. This header specifies the Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the part. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  229    229   
    pub fn get_checksum_crc64_nvme(&self) -> &::std::option::Option<::std::string::String> {
  230    230   
        &self.checksum_crc64_nvme
  231    231   
    }
  232         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         232  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  233    233   
    pub fn checksum_sha1(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  234    234   
        self.checksum_sha1 = ::std::option::Option::Some(input.into());
  235    235   
        self
  236    236   
    }
  237         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         237  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  238    238   
    pub fn set_checksum_sha1(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  239    239   
        self.checksum_sha1 = input;
  240    240   
        self
  241    241   
    }
  242         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         242  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  243    243   
    pub fn get_checksum_sha1(&self) -> &::std::option::Option<::std::string::String> {
  244    244   
        &self.checksum_sha1
  245    245   
    }
  246         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         246  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  247    247   
    pub fn checksum_sha256(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  248    248   
        self.checksum_sha256 = ::std::option::Option::Some(input.into());
  249    249   
        self
  250    250   
    }
  251         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         251  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  252    252   
    pub fn set_checksum_sha256(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  253    253   
        self.checksum_sha256 = input;
  254    254   
        self
  255    255   
    }
  256         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         256  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  257    257   
    pub fn get_checksum_sha256(&self) -> &::std::option::Option<::std::string::String> {
  258    258   
        &self.checksum_sha256
  259    259   
    }
  260    260   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to confirm the encryption algorithm that's used.</p><note>
  261    261   
    /// <p>This functionality is not supported for directory buckets.</p>
  262    262   
    /// </note>
  263    263   
    pub fn sse_customer_algorithm(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  264    264   
        self.sse_customer_algorithm = ::std::option::Option::Some(input.into());
  265    265   
        self
  266    266   
    }

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

@@ -35,35 +146,150 @@
   55     55   
/// <p><b>Directory buckets</b> - MD5 is not supported by directory buckets. You can use checksum algorithms to check object integrity.</p>
   56     56   
/// </note>
   57     57   
/// </dd>
   58     58   
/// <dt>
   59     59   
/// Encryption
   60     60   
/// </dt>
   61     61   
/// <dd>
   62     62   
/// <ul>
   63     63   
/// <li>
   64     64   
/// <p><b>General purpose bucket</b> - Server-side encryption is for data encryption at rest. Amazon S3 encrypts your data as it writes it to disks in its data centers and decrypts it when you access it. You have mutually exclusive options to protect data using server-side encryption in Amazon S3, depending on how you choose to manage the encryption keys. Specifically, the encryption key options are Amazon S3 managed keys (SSE-S3), Amazon Web Services KMS keys (SSE-KMS), and Customer-Provided Keys (SSE-C). Amazon S3 encrypts data with server-side encryption using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest using server-side encryption with other key options. The option you use depends on whether you want to use KMS keys (SSE-KMS) or provide your own encryption key (SSE-C).</p>
   65         -
/// <p>Server-side encryption is supported by the S3 Multipart Upload operations. Unless you are using a customer-provided encryption key (SSE-C), you don't need to specify the encryption parameters in each UploadPart request. Instead, you only need to specify the server-side encryption parameters in the initial Initiate Multipart request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html">CreateMultipartUpload</a>.</p>
          65  +
/// <p>Server-side encryption is supported by the S3 Multipart Upload operations. Unless you are using a customer-provided encryption key (SSE-C), you don't need to specify the encryption parameters in each UploadPart request. Instead, you only need to specify the server-side encryption parameters in the initial Initiate Multipart request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html">CreateMultipartUpload</a>.</p><note>
          66  +
/// <p>If you have server-side encryption with customer-provided keys (SSE-C) blocked for your general purpose bucket, you will get an HTTP 403 Access Denied error when you specify the SSE-C request headers while writing new data to your bucket. 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>
          67  +
/// </note>
   66     68   
/// <p>If you request server-side encryption using a customer-provided encryption key (SSE-C) in your initiate multipart upload request, you must provide identical encryption information in each part upload using the following request headers.</p>
   67     69   
/// <ul>
   68     70   
/// <li>
   69     71   
/// <p>x-amz-server-side-encryption-customer-algorithm</p></li>
   70     72   
/// <li>
   71     73   
/// <p>x-amz-server-side-encryption-customer-key</p></li>
   72     74   
/// <li>
   73     75   
/// <p>x-amz-server-side-encryption-customer-key-MD5</p></li>
   74     76   
/// </ul>
   75     77   
/// <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html">Using Server-Side Encryption</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   76     78   
/// <li>
   77     79   
/// <p><b>Directory buckets </b> - For directory buckets, there are only two supported options for server-side encryption: server-side encryption with Amazon S3 managed keys (SSE-S3) (<code>AES256</code>) and server-side encryption with KMS keys (SSE-KMS) (<code>aws:kms</code>).</p></li>
   78     80   
/// </ul>
   79     81   
/// </dd>
   80     82   
/// <dt>
   81     83   
/// Special errors
   82     84   
/// </dt>
   83     85   
/// <dd>
   84     86   
/// <ul>
   85     87   
/// <li>
   86     88   
/// <p>Error Code: <code>NoSuchUpload</code></p>
   87     89   
/// <ul>
   88     90   
/// <li>
   89     91   
/// <p>Description: The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.</p></li>
   90     92   
/// <li>
   91     93   
/// <p>HTTP Status Code: 404 Not Found</p></li>
   92     94   
/// <li>
   93     95   
/// <p>SOAP Fault Code Prefix: Client</p></li>
   94     96   
/// </ul></li>
   95     97   
/// </ul>
   96     98   
/// </dd>
   97     99   
/// <dt>
   98    100   
/// HTTP Host header syntax
   99    101   
/// </dt>
  100    102   
/// <dd>
  101    103   
/// <p><b>Directory buckets </b> - The HTTP Host header syntax is <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>.</p>
  102    104   
/// </dd>
  103    105   
/// </dl>
  104    106   
/// <p>The following operations are related to <code>UploadPart</code>:</p>
  105    107   
/// <ul>
  106    108   
/// <li>
  107    109   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html">CreateMultipartUpload</a></p></li>
  108    110   
/// <li>
  109    111   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html">CompleteMultipartUpload</a></p></li>
  110    112   
/// <li>
  111    113   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html">AbortMultipartUpload</a></p></li>
  112    114   
/// <li>
  113    115   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html">ListParts</a></p></li>
  114    116   
/// <li>
  115    117   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html">ListMultipartUploads</a></p></li>
  116         -
/// </ul>
         118  +
/// </ul><important>
         119  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
         120  +
/// </important>
  117    121   
#[derive(::std::fmt::Debug)]
  118    122   
pub struct UploadPartFluentBuilder {
  119    123   
    handle: ::std::sync::Arc<crate::client::Handle>,
  120    124   
    inner: crate::operation::upload_part::builders::UploadPartInputBuilder,
  121    125   
    config_override: ::std::option::Option<crate::config::Builder>,
  122    126   
}
  123    127   
impl
  124    128   
    crate::client::customize::internal::CustomizableSend<
  125    129   
        crate::operation::upload_part::UploadPartOutput,
  126    130   
        crate::operation::upload_part::UploadPartError,

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

@@ -46,46 +158,162 @@
   66     66   
/// <p>If the object is encrypted with SSE-KMS, you must also have the <code>kms:GenerateDataKey</code> and <code>kms:Decrypt</code> permissions in IAM identity-based policies and KMS key policies for the KMS key.</p>
   67     67   
/// <p>For example policies, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-security-iam-example-bucket-policies.html">Example bucket policies for S3 Express One Zone</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-security-iam-identity-policies.html">Amazon Web Services Identity and Access Management (IAM) identity-based policies for S3 Express One Zone</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   68     68   
/// </ul>
   69     69   
/// </dd>
   70     70   
/// <dt>
   71     71   
/// Encryption
   72     72   
/// </dt>
   73     73   
/// <dd>
   74     74   
/// <ul>
   75     75   
/// <li>
   76         -
/// <p><b>General purpose buckets </b> - For information about using server-side encryption with customer-provided encryption keys with the <code>UploadPartCopy</code> operation, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a>.</p></li>
          76  +
/// <p><b>General purpose buckets </b> - For information about using server-side encryption with customer-provided encryption keys with the <code>UploadPartCopy</code> operation, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a>.</p><note>
          77  +
/// <p>If you have server-side encryption with customer-provided keys (SSE-C) blocked for your general purpose bucket, you will get an HTTP 403 Access Denied error when you specify the SSE-C request headers while writing new data to your bucket. 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>
          78  +
/// </note></li>
   77     79   
/// <li>
   78     80   
/// <p><b>Directory buckets </b> - For directory buckets, there are only two supported options for server-side encryption: server-side encryption with Amazon S3 managed keys (SSE-S3) (<code>AES256</code>) and server-side encryption with KMS keys (SSE-KMS) (<code>aws:kms</code>). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-serv-side-encryption.html">Protecting data with server-side encryption</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   79     81   
/// <p>For directory buckets, when you perform a <code>CreateMultipartUpload</code> operation and an <code>UploadPartCopy</code> operation, the request headers you provide in the <code>CreateMultipartUpload</code> request must match the default encryption configuration of the destination bucket.</p>
   80     82   
/// </note>
   81     83   
/// <p>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_UploadPartCopy.html">UploadPartCopy</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>
   82     84   
/// </ul>
   83     85   
/// </dd>
   84     86   
/// <dt>
   85     87   
/// Special errors
   86     88   
/// </dt>
   87     89   
/// <dd>
   88     90   
/// <ul>
   89     91   
/// <li>
   90     92   
/// <p>Error Code: <code>NoSuchUpload</code></p>
   91     93   
/// <ul>
   92     94   
/// <li>
   93     95   
/// <p>Description: The specified multipart upload does not exist. The upload ID might be invalid, or the multipart upload might have been aborted or completed.</p></li>
   94     96   
/// <li>
   95     97   
/// <p>HTTP Status Code: 404 Not Found</p></li>
   96     98   
/// </ul></li>
   97     99   
/// <li>
   98    100   
/// <p>Error Code: <code>InvalidRequest</code></p>
   99    101   
/// <ul>
  100    102   
/// <li>
  101    103   
/// <p>Description: The specified copy source is not supported as a byte-range copy source.</p></li>
  102    104   
/// <li>
  103    105   
/// <p>HTTP Status Code: 400 Bad Request</p></li>
  104    106   
/// </ul></li>
  105    107   
/// </ul>
  106    108   
/// </dd>
  107    109   
/// <dt>
  108    110   
/// HTTP Host header syntax
  109    111   
/// </dt>
  110    112   
/// <dd>
  111    113   
/// <p><b>Directory buckets </b> - The HTTP Host header syntax is <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>.</p>
  112    114   
/// </dd>
  113    115   
/// </dl>
  114    116   
/// <p>The following operations are related to <code>UploadPartCopy</code>:</p>
  115    117   
/// <ul>
  116    118   
/// <li>
  117    119   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html">CreateMultipartUpload</a></p></li>
  118    120   
/// <li>
  119    121   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_UploadPart.html">UploadPart</a></p></li>
  120    122   
/// <li>
  121    123   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CompleteMultipartUpload.html">CompleteMultipartUpload</a></p></li>
  122    124   
/// <li>
  123    125   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_AbortMultipartUpload.html">AbortMultipartUpload</a></p></li>
  124    126   
/// <li>
  125    127   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListParts.html">ListParts</a></p></li>
  126    128   
/// <li>
  127    129   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html">ListMultipartUploads</a></p></li>
  128         -
/// </ul>
         130  +
/// </ul><important>
         131  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
         132  +
/// </important>
  129    133   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
  130    134   
pub struct UploadPartCopyFluentBuilder {
  131    135   
    handle: ::std::sync::Arc<crate::client::Handle>,
  132    136   
    inner: crate::operation::upload_part_copy::builders::UploadPartCopyInputBuilder,
  133    137   
    config_override: ::std::option::Option<crate::config::Builder>,
  134    138   
}
  135    139   
impl
  136    140   
    crate::client::customize::internal::CustomizableSend<
  137    141   
        crate::operation::upload_part_copy::UploadPartCopyOutput,
  138    142   
        crate::operation::upload_part_copy::UploadPartCopyError,

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

@@ -5,5 +65,67 @@
   25     25   
/// <note>
   26     26   
/// <p>This operation is not supported for directory buckets.</p>
   27     27   
/// </note>
   28     28   
/// <p>Passes transformed objects to a <code>GetObject</code> operation when using Object Lambda access points. For information about Object Lambda access points, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/transforming-objects.html">Transforming objects with Object Lambda access points</a> in the <i>Amazon S3 User Guide</i>.</p>
   29     29   
/// <p>This operation supports metadata that can be returned by <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html">GetObject</a>, in addition to <code>RequestRoute</code>, <code>RequestToken</code>, <code>StatusCode</code>, <code>ErrorCode</code>, and <code>ErrorMessage</code>. The <code>GetObject</code> response metadata is supported so that the <code>WriteGetObjectResponse</code> caller, typically an Lambda function, can provide the same metadata when it internally invokes <code>GetObject</code>. When <code>WriteGetObjectResponse</code> is called by a customer-owned Lambda function, the metadata returned to the end user <code>GetObject</code> call might differ from what Amazon S3 would normally return.</p>
   30     30   
/// <p>You can include any number of metadata headers. When including a metadata header, it should be prefaced with <code>x-amz-meta</code>. For example, <code>x-amz-meta-my-custom-header: MyCustomValue</code>. The primary use case for this is to forward <code>GetObject</code> metadata.</p>
   31     31   
/// <p>Amazon Web Services provides some prebuilt Lambda functions that you can use with S3 Object Lambda to detect and redact personally identifiable information (PII) and decompress S3 objects. These Lambda functions are available in the Amazon Web Services Serverless Application Repository, and can be selected through the Amazon Web Services Management Console when you create your Object Lambda access point.</p>
   32     32   
/// <p>Example 1: PII Access Control - This Lambda function uses Amazon Comprehend, a natural language processing (NLP) service using machine learning to find insights and relationships in text. It automatically detects personally identifiable information (PII) such as names, addresses, dates, credit card numbers, and social security numbers from documents in your Amazon S3 bucket.</p>
   33     33   
/// <p>Example 2: PII Redaction - This Lambda function uses Amazon Comprehend, a natural language processing (NLP) service using machine learning to find insights and relationships in text. It automatically redacts personally identifiable information (PII) such as names, addresses, dates, credit card numbers, and social security numbers from documents in your Amazon S3 bucket.</p>
   34     34   
/// <p>Example 3: Decompression - The Lambda function S3ObjectLambdaDecompression, is equipped to decompress objects stored in S3 in one of six compressed file formats including bzip2, gzip, snappy, zlib, zstandard and ZIP.</p>
   35         -
/// <p>For information on how to view and use these functions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/olap-examples.html">Using Amazon Web Services built Lambda functions</a> in the <i>Amazon S3 User Guide</i>.</p>
          35  +
/// <p>For information on how to view and use these functions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/olap-examples.html">Using Amazon Web Services built Lambda functions</a> in the <i>Amazon S3 User Guide</i>.</p><important>
          36  +
/// <p>You must URL encode any signed header values that contain spaces. For example, if your header value is <code>my file.txt</code>, containing two spaces after <code>my</code>, you must URL encode this value to <code>my%20%20file.txt</code>.</p>
          37  +
/// </important>
   36     38   
#[derive(::std::fmt::Debug)]
   37     39   
pub struct WriteGetObjectResponseFluentBuilder {
   38     40   
    handle: ::std::sync::Arc<crate::client::Handle>,
   39     41   
    inner: crate::operation::write_get_object_response::builders::WriteGetObjectResponseInputBuilder,
   40     42   
    config_override: ::std::option::Option<crate::config::Builder>,
   41     43   
}
   42     44   
impl
   43     45   
    crate::client::customize::internal::CustomizableSend<
   44     46   
        crate::operation::write_get_object_response::WriteGetObjectResponseOutput,
   45     47   
        crate::operation::write_get_object_response::WriteGetObjectResponseError,

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde.rs

@@ -74,74 +133,135 @@
   94     94   
pub(crate) mod shape_delete_object;
   95     95   
   96     96   
pub(crate) mod shape_delete_object_tagging;
   97     97   
   98     98   
pub(crate) mod shape_delete_objects;
   99     99   
  100    100   
pub(crate) mod shape_delete_objects_input;
  101    101   
  102    102   
pub(crate) mod shape_delete_public_access_block;
  103    103   
         104  +
pub(crate) mod shape_get_bucket_abac;
         105  +
  104    106   
pub(crate) mod shape_get_bucket_accelerate_configuration;
  105    107   
  106    108   
pub(crate) mod shape_get_bucket_acl;
  107    109   
  108    110   
pub(crate) mod shape_get_bucket_analytics_configuration;
  109    111   
  110    112   
pub(crate) mod shape_get_bucket_cors;
  111    113   
  112    114   
pub(crate) mod shape_get_bucket_encryption;
  113    115
@@ -162,164 +221,227 @@
  182    184   
pub(crate) mod shape_list_multipart_uploads;
  183    185   
  184    186   
pub(crate) mod shape_list_object_versions;
  185    187   
  186    188   
pub(crate) mod shape_list_objects;
  187    189   
  188    190   
pub(crate) mod shape_list_objects_v2;
  189    191   
  190    192   
pub(crate) mod shape_list_parts;
  191    193   
         194  +
pub(crate) mod shape_put_bucket_abac;
         195  +
         196  +
pub(crate) mod shape_put_bucket_abac_input;
         197  +
  192    198   
pub(crate) mod shape_put_bucket_accelerate_configuration;
  193    199   
  194    200   
pub(crate) mod shape_put_bucket_accelerate_configuration_input;
  195    201   
  196    202   
pub(crate) mod shape_put_bucket_acl;
  197    203   
  198    204   
pub(crate) mod shape_put_bucket_acl_input;
  199    205   
  200    206   
pub(crate) mod shape_put_bucket_analytics_configuration;
  201    207
@@ -312,318 +371,379 @@
  332    338   
pub(crate) mod shape_create_session_output;
  333    339   
  334    340   
pub(crate) mod shape_delete_object_output;
  335    341   
  336    342   
pub(crate) mod shape_delete_object_tagging_output;
  337    343   
  338    344   
pub(crate) mod shape_delete_objects_output;
  339    345   
  340    346   
pub(crate) mod shape_encryption_type_mismatch;
  341    347   
         348  +
pub(crate) mod shape_get_bucket_abac_output;
         349  +
  342    350   
pub(crate) mod shape_get_bucket_accelerate_configuration_output;
  343    351   
  344    352   
pub(crate) mod shape_get_bucket_analytics_configuration_output;
  345    353   
  346    354   
pub(crate) mod shape_get_bucket_encryption_output;
  347    355   
  348    356   
pub(crate) mod shape_get_bucket_intelligent_tiering_configuration_output;
  349    357   
  350    358   
pub(crate) mod shape_get_bucket_inventory_configuration_output;
  351    359
@@ -422,430 +481,491 @@
  442    450   
pub(crate) mod shape_upload_part_copy_output;
  443    451   
  444    452   
pub(crate) mod shape_upload_part_output;
  445    453   
  446    454   
pub fn parse_event_stream_error_metadata(
  447    455   
    payload: &::bytes::Bytes,
  448    456   
) -> ::std::result::Result<::aws_smithy_types::error::metadata::Builder, ::aws_smithy_xml::decode::XmlDecodeError> {
  449    457   
    crate::rest_xml_unwrapped_errors::parse_error_metadata(payload.as_ref())
  450    458   
}
  451    459   
         460  +
pub(crate) mod shape_abac_status;
         461  +
  452    462   
pub(crate) mod shape_accelerate_configuration;
  453    463   
  454    464   
pub(crate) mod shape_access_control_policy;
  455    465   
  456    466   
pub(crate) mod shape_analytics_configuration;
  457    467   
  458    468   
pub(crate) mod shape_bucket_lifecycle_configuration;
  459    469   
  460    470   
pub(crate) mod shape_bucket_logging_status;
  461    471
@@ -646,656 +705,717 @@
  666    676   
pub(crate) mod shape_target_grants;
  667    677   
  668    678   
pub(crate) mod shape_target_object_key_format;
  669    679   
  670    680   
pub(crate) mod shape_tiering;
  671    681   
  672    682   
pub(crate) mod shape_transition;
  673    683   
  674    684   
pub(crate) mod shape_analytics_and_operator;
  675    685   
         686  +
pub(crate) mod shape_blocked_encryption_types;
         687  +
  676    688   
pub(crate) mod shape_condition;
  677    689   
  678    690   
pub(crate) mod shape_default_retention;
  679    691   
  680    692   
pub(crate) mod shape_delete_marker_replication;
  681    693   
  682    694   
pub(crate) mod shape_destination;
  683    695   
  684    696   
pub(crate) mod shape_error_details;
  685    697

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_abac_status.rs

@@ -0,1 +0,42 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub fn ser_abac_status(
           3  +
    input: &crate::types::AbacStatus,
           4  +
    writer: ::aws_smithy_xml::encode::ElWriter,
           5  +
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
           6  +
    #[allow(unused_mut)]
           7  +
    let mut scope = writer.finish();
           8  +
    if let Some(var_1) = &input.status {
           9  +
        let mut inner_writer = scope.start_el("Status").finish();
          10  +
        inner_writer.data(var_1.as_str());
          11  +
    }
          12  +
    scope.finish();
          13  +
    Ok(())
          14  +
}
          15  +
          16  +
#[allow(clippy::needless_question_mark)]
          17  +
pub fn de_abac_status(
          18  +
    decoder: &mut ::aws_smithy_xml::decode::ScopedDecoder,
          19  +
) -> ::std::result::Result<crate::types::AbacStatus, ::aws_smithy_xml::decode::XmlDecodeError> {
          20  +
    #[allow(unused_mut)]
          21  +
    let mut builder = crate::types::AbacStatus::builder();
          22  +
    while let Some(mut tag) = decoder.next_tag() {
          23  +
        match tag.start_el() {
          24  +
            s if s.matches("Status") /* Status com.amazonaws.s3#AbacStatus$Status */ =>  {
          25  +
                let var_2 =
          26  +
                    Some(
          27  +
                        Result::<crate::types::BucketAbacStatus, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
          28  +
                            crate::types::BucketAbacStatus::from(
          29  +
                                ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
          30  +
                            )
          31  +
                        )
          32  +
                        ?
          33  +
                    )
          34  +
                ;
          35  +
                builder = builder.set_status(var_2);
          36  +
            }
          37  +
            ,
          38  +
            _ => {}
          39  +
        }
          40  +
    }
          41  +
    Ok(builder.build())
          42  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_blocked_encryption_types.rs

@@ -0,1 +0,53 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub fn ser_blocked_encryption_types(
           3  +
    input: &crate::types::BlockedEncryptionTypes,
           4  +
    writer: ::aws_smithy_xml::encode::ElWriter,
           5  +
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
           6  +
    #[allow(unused_mut)]
           7  +
    let mut scope = writer.finish();
           8  +
    if let Some(var_1) = &input.encryption_type {
           9  +
        for list_item_2 in var_1 {
          10  +
            {
          11  +
                let mut inner_writer = scope.start_el("EncryptionType").finish();
          12  +
                inner_writer.data(list_item_2.as_str());
          13  +
            }
          14  +
        }
          15  +
    }
          16  +
    scope.finish();
          17  +
    Ok(())
          18  +
}
          19  +
          20  +
#[allow(clippy::needless_question_mark)]
          21  +
pub fn de_blocked_encryption_types(
          22  +
    decoder: &mut ::aws_smithy_xml::decode::ScopedDecoder,
          23  +
) -> ::std::result::Result<crate::types::BlockedEncryptionTypes, ::aws_smithy_xml::decode::XmlDecodeError> {
          24  +
    #[allow(unused_mut)]
          25  +
    let mut builder = crate::types::BlockedEncryptionTypes::builder();
          26  +
    while let Some(mut tag) = decoder.next_tag() {
          27  +
        match tag.start_el() {
          28  +
            s if s.matches("EncryptionType") /* EncryptionType com.amazonaws.s3#BlockedEncryptionTypes$EncryptionType */ =>  {
          29  +
                let var_3 =
          30  +
                    Some(
          31  +
                        Result::<::std::vec::Vec::<crate::types::EncryptionType>, ::aws_smithy_xml::decode::XmlDecodeError>::Ok({
          32  +
                            let mut list_4 = builder.encryption_type.take().unwrap_or_default();
          33  +
                            list_4.push(
          34  +
                                Result::<crate::types::EncryptionType, ::aws_smithy_xml::decode::XmlDecodeError>::Ok(
          35  +
                                    crate::types::EncryptionType::from(
          36  +
                                        ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
          37  +
                                    )
          38  +
                                )
          39  +
                                ?
          40  +
                            );
          41  +
                            list_4
          42  +
                        })
          43  +
                        ?
          44  +
                    )
          45  +
                ;
          46  +
                builder = builder.set_encryption_type(var_3);
          47  +
            }
          48  +
            ,
          49  +
            _ => {}
          50  +
        }
          51  +
    }
          52  +
    Ok(builder.build())
          53  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_copy_object.rs

@@ -282,282 +566,588 @@
  302    302   
        let formatted_34 = inner_33.as_str();
  303    303   
        let header_value = formatted_34;
  304    304   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  305    305   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  306    306   
                "grant_write_acp",
  307    307   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  308    308   
            )
  309    309   
        })?;
  310    310   
        builder = builder.header("x-amz-grant-write-acp", header_value);
  311    311   
    }
  312         -
    if let ::std::option::Option::Some(inner_35) = &input.metadata_directive {
         312  +
    if let ::std::option::Option::Some(inner_35) = &input.if_match {
  313    313   
        let formatted_36 = inner_35.as_str();
  314    314   
        let header_value = formatted_36;
  315    315   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  316    316   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  317         -
                "metadata_directive",
         317  +
                "if_match",
  318    318   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  319    319   
            )
  320    320   
        })?;
  321         -
        builder = builder.header("x-amz-metadata-directive", header_value);
         321  +
        builder = builder.header("If-Match", header_value);
  322    322   
    }
  323         -
    if let ::std::option::Option::Some(inner_37) = &input.tagging_directive {
         323  +
    if let ::std::option::Option::Some(inner_37) = &input.if_none_match {
  324    324   
        let formatted_38 = inner_37.as_str();
  325    325   
        let header_value = formatted_38;
  326    326   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  327    327   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  328         -
                "tagging_directive",
         328  +
                "if_none_match",
  329    329   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  330    330   
            )
  331    331   
        })?;
  332         -
        builder = builder.header("x-amz-tagging-directive", header_value);
         332  +
        builder = builder.header("If-None-Match", header_value);
  333    333   
    }
  334         -
    if let ::std::option::Option::Some(inner_39) = &input.server_side_encryption {
         334  +
    if let ::std::option::Option::Some(inner_39) = &input.metadata_directive {
  335    335   
        let formatted_40 = inner_39.as_str();
  336    336   
        let header_value = formatted_40;
  337    337   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  338    338   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  339         -
                "server_side_encryption",
         339  +
                "metadata_directive",
  340    340   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  341    341   
            )
  342    342   
        })?;
  343         -
        builder = builder.header("x-amz-server-side-encryption", header_value);
         343  +
        builder = builder.header("x-amz-metadata-directive", header_value);
  344    344   
    }
  345         -
    if let ::std::option::Option::Some(inner_41) = &input.storage_class {
         345  +
    if let ::std::option::Option::Some(inner_41) = &input.tagging_directive {
  346    346   
        let formatted_42 = inner_41.as_str();
  347    347   
        let header_value = formatted_42;
  348    348   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  349    349   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  350         -
                "storage_class",
         350  +
                "tagging_directive",
  351    351   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  352    352   
            )
  353    353   
        })?;
  354         -
        builder = builder.header("x-amz-storage-class", header_value);
         354  +
        builder = builder.header("x-amz-tagging-directive", header_value);
  355    355   
    }
  356         -
    if let ::std::option::Option::Some(inner_43) = &input.website_redirect_location {
         356  +
    if let ::std::option::Option::Some(inner_43) = &input.server_side_encryption {
  357    357   
        let formatted_44 = inner_43.as_str();
  358    358   
        let header_value = formatted_44;
  359    359   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  360    360   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  361         -
                "website_redirect_location",
         361  +
                "server_side_encryption",
  362    362   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  363    363   
            )
  364    364   
        })?;
  365         -
        builder = builder.header("x-amz-website-redirect-location", header_value);
         365  +
        builder = builder.header("x-amz-server-side-encryption", header_value);
  366    366   
    }
  367         -
    if let ::std::option::Option::Some(inner_45) = &input.sse_customer_algorithm {
         367  +
    if let ::std::option::Option::Some(inner_45) = &input.storage_class {
  368    368   
        let formatted_46 = inner_45.as_str();
  369    369   
        let header_value = formatted_46;
  370    370   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  371    371   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  372         -
                "sse_customer_algorithm",
         372  +
                "storage_class",
  373    373   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  374    374   
            )
  375    375   
        })?;
  376         -
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
         376  +
        builder = builder.header("x-amz-storage-class", header_value);
  377    377   
    }
  378         -
    if let ::std::option::Option::Some(inner_47) = &input.sse_customer_key {
         378  +
    if let ::std::option::Option::Some(inner_47) = &input.website_redirect_location {
  379    379   
        let formatted_48 = inner_47.as_str();
  380    380   
        let header_value = formatted_48;
         381  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
         382  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
         383  +
                "website_redirect_location",
         384  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
         385  +
            )
         386  +
        })?;
         387  +
        builder = builder.header("x-amz-website-redirect-location", header_value);
         388  +
    }
         389  +
    if let ::std::option::Option::Some(inner_49) = &input.sse_customer_algorithm {
         390  +
        let formatted_50 = inner_49.as_str();
         391  +
        let header_value = formatted_50;
         392  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
         393  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
         394  +
                "sse_customer_algorithm",
         395  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
         396  +
            )
         397  +
        })?;
         398  +
        builder = builder.header("x-amz-server-side-encryption-customer-algorithm", header_value);
         399  +
    }
         400  +
    if let ::std::option::Option::Some(inner_51) = &input.sse_customer_key {
         401  +
        let formatted_52 = inner_51.as_str();
         402  +
        let header_value = formatted_52;
  381    403   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  382    404   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  383    405   
                "sse_customer_key",
  384    406   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  385    407   
            )
  386    408   
        })?;
  387    409   
        builder = builder.header("x-amz-server-side-encryption-customer-key", header_value);
  388    410   
    }
  389         -
    if let ::std::option::Option::Some(inner_49) = &input.sse_customer_key_md5 {
  390         -
        let formatted_50 = inner_49.as_str();
  391         -
        let header_value = formatted_50;
         411  +
    if let ::std::option::Option::Some(inner_53) = &input.sse_customer_key_md5 {
         412  +
        let formatted_54 = inner_53.as_str();
         413  +
        let header_value = formatted_54;
  392    414   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  393    415   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  394    416   
                "sse_customer_key_md5",
  395    417   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  396    418   
            )
  397    419   
        })?;
  398    420   
        builder = builder.header("x-amz-server-side-encryption-customer-key-MD5", header_value);
  399    421   
    }
  400         -
    if let ::std::option::Option::Some(inner_51) = &input.ssekms_key_id {
  401         -
        let formatted_52 = inner_51.as_str();
  402         -
        let header_value = formatted_52;
         422  +
    if let ::std::option::Option::Some(inner_55) = &input.ssekms_key_id {
         423  +
        let formatted_56 = inner_55.as_str();
         424  +
        let header_value = formatted_56;
  403    425   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  404    426   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  405    427   
                "ssekms_key_id",
  406    428   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  407    429   
            )
  408    430   
        })?;
  409    431   
        builder = builder.header("x-amz-server-side-encryption-aws-kms-key-id", header_value);
  410    432   
    }
  411         -
    if let ::std::option::Option::Some(inner_53) = &input.ssekms_encryption_context {
  412         -
        let formatted_54 = inner_53.as_str();
  413         -
        let header_value = formatted_54;
         433  +
    if let ::std::option::Option::Some(inner_57) = &input.ssekms_encryption_context {
         434  +
        let formatted_58 = inner_57.as_str();
         435  +
        let header_value = formatted_58;
  414    436   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  415    437   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  416    438   
                "ssekms_encryption_context",
  417    439   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  418    440   
            )
  419    441   
        })?;
  420    442   
        builder = builder.header("x-amz-server-side-encryption-context", header_value);
  421    443   
    }
  422         -
    if let ::std::option::Option::Some(inner_55) = &input.bucket_key_enabled {
  423         -
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_55);
  424         -
        let formatted_56 = encoder.encode();
  425         -
        let header_value = formatted_56;
         444  +
    if let ::std::option::Option::Some(inner_59) = &input.bucket_key_enabled {
         445  +
        let mut encoder = ::aws_smithy_types::primitive::Encoder::from(*inner_59);
         446  +
        let formatted_60 = encoder.encode();
         447  +
        let header_value = formatted_60;
  426    448   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  427    449   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  428    450   
                "bucket_key_enabled",
  429    451   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  430    452   
            )
  431    453   
        })?;
  432    454   
        builder = builder.header("x-amz-server-side-encryption-bucket-key-enabled", header_value);
  433    455   
    }
  434         -
    if let ::std::option::Option::Some(inner_57) = &input.copy_source_sse_customer_algorithm {
  435         -
        let formatted_58 = inner_57.as_str();
  436         -
        let header_value = formatted_58;
         456  +
    if let ::std::option::Option::Some(inner_61) = &input.copy_source_sse_customer_algorithm {
         457  +
        let formatted_62 = inner_61.as_str();
         458  +
        let header_value = formatted_62;
  437    459   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  438    460   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  439    461   
                "copy_source_sse_customer_algorithm",
  440    462   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  441    463   
            )
  442    464   
        })?;
  443    465   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-algorithm", header_value);
  444    466   
    }
  445         -
    if let ::std::option::Option::Some(inner_59) = &input.copy_source_sse_customer_key {
  446         -
        let formatted_60 = inner_59.as_str();
  447         -
        let header_value = formatted_60;
         467  +
    if let ::std::option::Option::Some(inner_63) = &input.copy_source_sse_customer_key {
         468  +
        let formatted_64 = inner_63.as_str();
         469  +
        let header_value = formatted_64;
  448    470   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  449    471   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  450    472   
                "copy_source_sse_customer_key",
  451    473   
                format!("`{}` cannot be used as a header value: {}", &"*** Sensitive Data Redacted ***", err),
  452    474   
            )
  453    475   
        })?;
  454    476   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key", header_value);
  455    477   
    }
  456         -
    if let ::std::option::Option::Some(inner_61) = &input.copy_source_sse_customer_key_md5 {
  457         -
        let formatted_62 = inner_61.as_str();
  458         -
        let header_value = formatted_62;
         478  +
    if let ::std::option::Option::Some(inner_65) = &input.copy_source_sse_customer_key_md5 {
         479  +
        let formatted_66 = inner_65.as_str();
         480  +
        let header_value = formatted_66;
  459    481   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  460    482   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  461    483   
                "copy_source_sse_customer_key_md5",
  462    484   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  463    485   
            )
  464    486   
        })?;
  465    487   
        builder = builder.header("x-amz-copy-source-server-side-encryption-customer-key-MD5", header_value);
  466    488   
    }
  467         -
    if let ::std::option::Option::Some(inner_63) = &input.request_payer {
  468         -
        let formatted_64 = inner_63.as_str();
  469         -
        let header_value = formatted_64;
         489  +
    if let ::std::option::Option::Some(inner_67) = &input.request_payer {
         490  +
        let formatted_68 = inner_67.as_str();
         491  +
        let header_value = formatted_68;
  470    492   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  471    493   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  472    494   
                "request_payer",
  473    495   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  474    496   
            )
  475    497   
        })?;
  476    498   
        builder = builder.header("x-amz-request-payer", header_value);
  477    499   
    }
  478         -
    if let ::std::option::Option::Some(inner_65) = &input.tagging {
  479         -
        let formatted_66 = inner_65.as_str();
  480         -
        let header_value = formatted_66;
         500  +
    if let ::std::option::Option::Some(inner_69) = &input.tagging {
         501  +
        let formatted_70 = inner_69.as_str();
         502  +
        let header_value = formatted_70;
  481    503   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  482    504   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  483    505   
                "tagging",
  484    506   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  485    507   
            )
  486    508   
        })?;
  487    509   
        builder = builder.header("x-amz-tagging", header_value);
  488    510   
    }
  489         -
    if let ::std::option::Option::Some(inner_67) = &input.object_lock_mode {
  490         -
        let formatted_68 = inner_67.as_str();
  491         -
        let header_value = formatted_68;
         511  +
    if let ::std::option::Option::Some(inner_71) = &input.object_lock_mode {
         512  +
        let formatted_72 = inner_71.as_str();
         513  +
        let header_value = formatted_72;
  492    514   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  493    515   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  494    516   
                "object_lock_mode",
  495    517   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  496    518   
            )
  497    519   
        })?;
  498    520   
        builder = builder.header("x-amz-object-lock-mode", header_value);
  499    521   
    }
  500         -
    if let ::std::option::Option::Some(inner_69) = &input.object_lock_retain_until_date {
  501         -
        let formatted_70 = inner_69.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
  502         -
        let header_value = formatted_70;
         522  +
    if let ::std::option::Option::Some(inner_73) = &input.object_lock_retain_until_date {
         523  +
        let formatted_74 = inner_73.fmt(::aws_smithy_types::date_time::Format::DateTime)?;
         524  +
        let header_value = formatted_74;
  503    525   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  504    526   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  505    527   
                "object_lock_retain_until_date",
  506    528   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  507    529   
            )
  508    530   
        })?;
  509    531   
        builder = builder.header("x-amz-object-lock-retain-until-date", header_value);
  510    532   
    }
  511         -
    if let ::std::option::Option::Some(inner_71) = &input.object_lock_legal_hold_status {
  512         -
        let formatted_72 = inner_71.as_str();
  513         -
        let header_value = formatted_72;
         533  +
    if let ::std::option::Option::Some(inner_75) = &input.object_lock_legal_hold_status {
         534  +
        let formatted_76 = inner_75.as_str();
         535  +
        let header_value = formatted_76;
  514    536   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  515    537   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  516    538   
                "object_lock_legal_hold_status",
  517    539   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  518    540   
            )
  519    541   
        })?;
  520    542   
        builder = builder.header("x-amz-object-lock-legal-hold", header_value);
  521    543   
    }
  522         -
    if let ::std::option::Option::Some(inner_73) = &input.expected_bucket_owner {
  523         -
        let formatted_74 = inner_73.as_str();
  524         -
        let header_value = formatted_74;
         544  +
    if let ::std::option::Option::Some(inner_77) = &input.expected_bucket_owner {
         545  +
        let formatted_78 = inner_77.as_str();
         546  +
        let header_value = formatted_78;
  525    547   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  526    548   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  527    549   
                "expected_bucket_owner",
  528    550   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  529    551   
            )
  530    552   
        })?;
  531    553   
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
  532    554   
    }
  533         -
    if let ::std::option::Option::Some(inner_75) = &input.expected_source_bucket_owner {
  534         -
        let formatted_76 = inner_75.as_str();
  535         -
        let header_value = formatted_76;
         555  +
    if let ::std::option::Option::Some(inner_79) = &input.expected_source_bucket_owner {
         556  +
        let formatted_80 = inner_79.as_str();
         557  +
        let header_value = formatted_80;
  536    558   
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  537    559   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  538    560   
                "expected_source_bucket_owner",
  539    561   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  540    562   
            )
  541    563   
        })?;
  542    564   
        builder = builder.header("x-amz-source-expected-bucket-owner", header_value);
  543    565   
    }
  544         -
    if let ::std::option::Option::Some(inner_77) = &input.metadata {
         566  +
    if let ::std::option::Option::Some(inner_81) = &input.metadata {
  545    567   
        {
  546         -
            for (k, v) in inner_77 {
         568  +
            for (k, v) in inner_81 {
  547    569   
                use std::str::FromStr;
  548    570   
                let header_name = ::http_1x::HeaderName::from_str(&format!("{}{}", "x-amz-meta-", &k)).map_err(|err| {
  549    571   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(
  550    572   
                        "metadata",
  551    573   
                        format!("`{k}` cannot be used as a header name: {err}"),
  552    574   
                    )
  553    575   
                })?;
  554    576   
                let header_value = v.as_str();
  555    577   
                let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  556    578   
                    ::aws_smithy_types::error::operation::BuildError::invalid_field(

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_abac.rs

@@ -0,1 +0,51 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(clippy::unnecessary_wraps)]
           3  +
pub fn de_get_bucket_abac_http_error(
           4  +
    _response_status: u16,
           5  +
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
           6  +
    _response_body: &[u8],
           7  +
) -> std::result::Result<crate::operation::get_bucket_abac::GetBucketAbacOutput, crate::operation::get_bucket_abac::GetBucketAbacError> {
           8  +
    #[allow(unused_mut)]
           9  +
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
          10  +
        .map_err(crate::operation::get_bucket_abac::GetBucketAbacError::unhandled)?;
          11  +
    generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
          12  +
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
          13  +
    let generic = generic_builder.build();
          14  +
    Err(crate::operation::get_bucket_abac::GetBucketAbacError::generic(generic))
          15  +
}
          16  +
          17  +
#[allow(clippy::unnecessary_wraps)]
          18  +
pub fn de_get_bucket_abac_http_response(
          19  +
    _response_status: u16,
          20  +
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
          21  +
    _response_body: &[u8],
          22  +
) -> std::result::Result<crate::operation::get_bucket_abac::GetBucketAbacOutput, crate::operation::get_bucket_abac::GetBucketAbacError> {
          23  +
    Ok({
          24  +
        #[allow(unused_mut)]
          25  +
        let mut output = crate::operation::get_bucket_abac::builders::GetBucketAbacOutputBuilder::default();
          26  +
        output = output.set_abac_status(crate::protocol_serde::shape_get_bucket_abac_output::de_abac_status_payload(
          27  +
            _response_body,
          28  +
        )?);
          29  +
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
          30  +
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
          31  +
        output.build()
          32  +
    })
          33  +
}
          34  +
          35  +
pub fn ser_get_bucket_abac_headers(
          36  +
    input: &crate::operation::get_bucket_abac::GetBucketAbacInput,
          37  +
    mut builder: ::http_1x::request::Builder,
          38  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          39  +
    if let ::std::option::Option::Some(inner_1) = &input.expected_bucket_owner {
          40  +
        let formatted_2 = inner_1.as_str();
          41  +
        let header_value = formatted_2;
          42  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
          43  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
          44  +
                "expected_bucket_owner",
          45  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
          46  +
            )
          47  +
        })?;
          48  +
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
          49  +
    }
          50  +
    Ok(builder)
          51  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_get_bucket_abac_output.rs

@@ -0,1 +0,24 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub(crate) fn de_abac_status_payload(
           3  +
    body: &[u8],
           4  +
) -> std::result::Result<::std::option::Option<crate::types::AbacStatus>, crate::operation::get_bucket_abac::GetBucketAbacError> {
           5  +
    (!body.is_empty())
           6  +
        .then(|| {
           7  +
            crate::protocol_serde::shape_get_bucket_abac_output::de_abac_status(body)
           8  +
                .map_err(crate::operation::get_bucket_abac::GetBucketAbacError::unhandled)
           9  +
        })
          10  +
        .transpose()
          11  +
}
          12  +
          13  +
pub fn de_abac_status(inp: &[u8]) -> std::result::Result<crate::types::AbacStatus, ::aws_smithy_xml::decode::XmlDecodeError> {
          14  +
    let mut doc = ::aws_smithy_xml::decode::Document::try_from(inp)?;
          15  +
    #[allow(unused_mut)]
          16  +
    let mut decoder = doc.root_element()?;
          17  +
    let start_el = decoder.start_el();
          18  +
    if !(start_el.matches("AbacStatus")) {
          19  +
        return Err(::aws_smithy_xml::decode::XmlDecodeError::custom(format!(
          20  +
            "invalid root, expected AbacStatus got {start_el:?}"
          21  +
        )));
          22  +
    }
          23  +
    crate::protocol_serde::shape_abac_status::de_abac_status(&mut decoder)
          24  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_put_bucket_abac.rs

@@ -0,1 +0,70 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(clippy::unnecessary_wraps)]
           3  +
pub fn de_put_bucket_abac_http_error(
           4  +
    _response_status: u16,
           5  +
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
           6  +
    _response_body: &[u8],
           7  +
) -> std::result::Result<crate::operation::put_bucket_abac::PutBucketAbacOutput, crate::operation::put_bucket_abac::PutBucketAbacError> {
           8  +
    #[allow(unused_mut)]
           9  +
    let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(_response_status, _response_headers, _response_body)
          10  +
        .map_err(crate::operation::put_bucket_abac::PutBucketAbacError::unhandled)?;
          11  +
    generic_builder = crate::s3_request_id::apply_extended_request_id(generic_builder, _response_headers);
          12  +
    generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, _response_headers);
          13  +
    let generic = generic_builder.build();
          14  +
    Err(crate::operation::put_bucket_abac::PutBucketAbacError::generic(generic))
          15  +
}
          16  +
          17  +
#[allow(clippy::unnecessary_wraps)]
          18  +
pub fn de_put_bucket_abac_http_response(
          19  +
    _response_status: u16,
          20  +
    _response_headers: &::aws_smithy_runtime_api::http::Headers,
          21  +
    _response_body: &[u8],
          22  +
) -> std::result::Result<crate::operation::put_bucket_abac::PutBucketAbacOutput, crate::operation::put_bucket_abac::PutBucketAbacError> {
          23  +
    Ok({
          24  +
        #[allow(unused_mut)]
          25  +
        let mut output = crate::operation::put_bucket_abac::builders::PutBucketAbacOutputBuilder::default();
          26  +
        output._set_extended_request_id(crate::s3_request_id::RequestIdExt::extended_request_id(_response_headers).map(str::to_string));
          27  +
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
          28  +
        output.build()
          29  +
    })
          30  +
}
          31  +
          32  +
pub fn ser_put_bucket_abac_headers(
          33  +
    input: &crate::operation::put_bucket_abac::PutBucketAbacInput,
          34  +
    mut builder: ::http_1x::request::Builder,
          35  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
          36  +
    if let ::std::option::Option::Some(inner_1) = &input.content_md5 {
          37  +
        let formatted_2 = inner_1.as_str();
          38  +
        let header_value = formatted_2;
          39  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
          40  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
          41  +
                "content_md5",
          42  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
          43  +
            )
          44  +
        })?;
          45  +
        builder = builder.header("Content-MD5", header_value);
          46  +
    }
          47  +
    if let ::std::option::Option::Some(inner_3) = &input.checksum_algorithm {
          48  +
        let formatted_4 = inner_3.as_str();
          49  +
        let header_value = formatted_4;
          50  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
          51  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
          52  +
                "checksum_algorithm",
          53  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
          54  +
            )
          55  +
        })?;
          56  +
        builder = builder.header("x-amz-sdk-checksum-algorithm", header_value);
          57  +
    }
          58  +
    if let ::std::option::Option::Some(inner_5) = &input.expected_bucket_owner {
          59  +
        let formatted_6 = inner_5.as_str();
          60  +
        let header_value = formatted_6;
          61  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
          62  +
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
          63  +
                "expected_bucket_owner",
          64  +
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
          65  +
            )
          66  +
        })?;
          67  +
        builder = builder.header("x-amz-expected-bucket-owner", header_value);
          68  +
    }
          69  +
    Ok(builder)
          70  +
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/protocol_serde/shape_put_bucket_abac_input.rs

@@ -0,1 +0,23 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub fn ser_abac_status_http_payload(
           3  +
    payload: &::std::option::Option<crate::types::AbacStatus>,
           4  +
) -> ::std::result::Result<::std::vec::Vec<u8>, ::aws_smithy_types::error::operation::BuildError> {
           5  +
    let payload = match payload.as_ref() {
           6  +
        Some(t) => t,
           7  +
        None => return Ok(crate::protocol_serde::rest_xml_unset_struct_payload()),
           8  +
    };
           9  +
    Ok(crate::protocol_serde::shape_put_bucket_abac_input::ser_abac_status_payload(payload)?)
          10  +
}
          11  +
          12  +
pub fn ser_abac_status_payload(
          13  +
    input: &crate::types::AbacStatus,
          14  +
) -> std::result::Result<std::vec::Vec<u8>, ::aws_smithy_types::error::operation::SerializationError> {
          15  +
    let mut out = String::new();
          16  +
    {
          17  +
        let mut writer = ::aws_smithy_xml::encode::XmlWriter::new(&mut out);
          18  +
        #[allow(unused_mut)]
          19  +
        let mut root = writer.start_el("AbacStatus").write_ns("http://s3.amazonaws.com/doc/2006-03-01/", None);
          20  +
        crate::protocol_serde::shape_abac_status::ser_abac_status(input, root)?
          21  +
    }
          22  +
    Ok(out.into_bytes())
          23  +
}