AWS SDK

AWS SDK

rev. e6785b15a6b118e5a6960c94143c0d982a485bbb

Files changed:

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

@@ -1,1 +58,55 @@
   15     15   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   16     16   
        >,
   17     17   
    > {
   18     18   
        let mut fluent_builder = client.put_bucket_acl();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `PutBucketAcl`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will discontinue support for creating new Email Grantee Access Control Lists (ACL). Email Grantee ACLs created prior to this date will continue to work and remain accessible through the Amazon Web Services Management Console, Command Line Interface (CLI), SDKs, and REST API. However, you will no longer be able to create new Email Grantee ACLs.</p>
   27         -
/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>
   28         -
/// </important> <note>
          25  +
/// <note>
   29     26   
/// <p>This operation is not supported for directory buckets.</p>
   30     27   
/// </note>
   31     28   
/// <p>Sets the permissions on an existing bucket using access control lists (ACL). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/S3_ACLs_UsingACLs.html">Using ACLs</a>. To set the ACL of a bucket, you must have the <code>WRITE_ACP</code> permission.</p>
   32     29   
/// <p>You can use one of the following two ways to set a bucket's permissions:</p>
   33     30   
/// <ul>
   34     31   
/// <li>
   35     32   
/// <p>Specify the ACL in the request body</p></li>
   36     33   
/// <li>
   37     34   
/// <p>Specify permissions using request headers</p></li>
   38     35   
/// </ul><note>
@@ -64,61 +124,121 @@
   84     81   
/// </ul>
   85     82   
/// <p>For example, the following <code>x-amz-grant-write</code> header grants create, overwrite, and delete objects permission to LogDelivery group predefined by Amazon S3 and two Amazon Web Services accounts identified by their email addresses.</p>
   86     83   
/// <p><code>x-amz-grant-write: uri="http://acs.amazonaws.com/groups/s3/LogDelivery", id="111122223333", id="555566667777" </code></p></li>
   87     84   
/// </ul>
   88     85   
/// <p>You can use either a canned ACL or specify access permissions explicitly. You cannot do both.</p>
   89     86   
/// </dd>
   90     87   
/// <dt>
   91     88   
/// Grantee Values
   92     89   
/// </dt>
   93     90   
/// <dd>
   94         -
/// <p>You can specify the person (grantee) to whom you're assigning access rights (using request elements) in the following ways. For examples of how to specify these grantee values in JSON format, see the Amazon Web Services CLI example in <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html"> Enabling Amazon S3 server access logging</a> in the <i>Amazon S3 User Guide</i>.</p>
          91  +
/// <p>You can specify the person (grantee) to whom you're assigning access rights (using request elements) in the following ways:</p>
   95     92   
/// <ul>
   96     93   
/// <li>
   97     94   
/// <p>By the person's ID:</p>
   98     95   
/// <p><code><grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
   99     96   
/// <id>
  100     97   
/// &lt;&gt;ID&lt;&gt;
  101     98   
/// </id>
  102     99   
/// <displayname>
  103    100   
/// &lt;&gt;GranteesEmail&lt;&gt;
  104    101   
/// </displayname>

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

@@ -211,211 +271,270 @@
  231    231   
                ::std::result::Result::Ok(())
  232    232   
            }
  233    233   
            #[allow(clippy::unnecessary_wraps)]
  234    234   
            fn update_http_builder(
  235    235   
                input: &crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput,
  236    236   
                builder: ::http::request::Builder,
  237    237   
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  238    238   
                let mut uri = ::std::string::String::new();
  239    239   
                uri_base(input, &mut uri)?;
  240    240   
                uri_query(input, &mut uri)?;
  241         -
                let builder = crate::protocol_serde::shape_put_bucket_intelligent_tiering_configuration::ser_put_bucket_intelligent_tiering_configuration_headers(input, builder)?;
  242    241   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  243    242   
            }
  244    243   
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  245    244   
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
  246    245   
            builder
  247    246   
        };
  248    247   
        let body = ::aws_smithy_types::body::SdkBody::from(
  249    248   
            crate::protocol_serde::shape_put_bucket_intelligent_tiering_configuration_input::ser_intelligent_tiering_configuration_http_payload(
  250    249   
                &input.intelligent_tiering_configuration,
  251    250   
            )?,

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_bucket_intelligent_tiering_configuration/_put_bucket_intelligent_tiering_configuration_input.rs

@@ -1,1 +126,104 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct PutBucketIntelligentTieringConfigurationInput {
    6      6   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
    7      7   
    pub bucket: ::std::option::Option<::std::string::String>,
    8      8   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
    9      9   
    pub id: ::std::option::Option<::std::string::String>,
   10         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
   11         -
    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,
   12     10   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
   13     11   
    pub intelligent_tiering_configuration: ::std::option::Option<crate::types::IntelligentTieringConfiguration>,
   14     12   
}
   15     13   
impl PutBucketIntelligentTieringConfigurationInput {
   16     14   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   17     15   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   18     16   
        self.bucket.as_deref()
   19     17   
    }
   20     18   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
   21     19   
    pub fn id(&self) -> ::std::option::Option<&str> {
   22     20   
        self.id.as_deref()
   23     21   
    }
   24         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
   25         -
    pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
   26         -
        self.expected_bucket_owner.as_deref()
   27         -
    }
   28     22   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
   29     23   
    pub fn intelligent_tiering_configuration(&self) -> ::std::option::Option<&crate::types::IntelligentTieringConfiguration> {
   30     24   
        self.intelligent_tiering_configuration.as_ref()
   31     25   
    }
   32     26   
}
   33     27   
impl PutBucketIntelligentTieringConfigurationInput {
   34     28   
    /// Creates a new builder-style object to manufacture [`PutBucketIntelligentTieringConfigurationInput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput).
   35     29   
    pub fn builder() -> crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationInputBuilder
   36     30   
    {
   37     31   
        crate::operation::put_bucket_intelligent_tiering_configuration::builders::PutBucketIntelligentTieringConfigurationInputBuilder::default()
   38     32   
    }
   39     33   
}
   40     34   
   41     35   
/// A builder for [`PutBucketIntelligentTieringConfigurationInput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput).
   42     36   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   43     37   
#[non_exhaustive]
   44     38   
pub struct PutBucketIntelligentTieringConfigurationInputBuilder {
   45     39   
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
   46     40   
    pub(crate) id: ::std::option::Option<::std::string::String>,
   47         -
    pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
   48     41   
    pub(crate) intelligent_tiering_configuration: ::std::option::Option<crate::types::IntelligentTieringConfiguration>,
   49     42   
}
   50     43   
impl PutBucketIntelligentTieringConfigurationInputBuilder {
   51     44   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   52     45   
    /// This field is required.
   53     46   
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   54     47   
        self.bucket = ::std::option::Option::Some(input.into());
   55     48   
        self
   56     49   
    }
   57     50   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   58     51   
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   59     52   
        self.bucket = input;
   60     53   
        self
   61     54   
    }
   62     55   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   63     56   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
   64     57   
        &self.bucket
   65     58   
    }
   66     59   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
   67     60   
    /// This field is required.
   68     61   
    pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   69     62   
        self.id = ::std::option::Option::Some(input.into());
   70     63   
        self
   71     64   
    }
   72     65   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
   73     66   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   74     67   
        self.id = input;
   75     68   
        self
   76     69   
    }
   77     70   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
   78     71   
    pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
   79     72   
        &self.id
   80     73   
    }
   81         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
   82         -
    pub fn expected_bucket_owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   83         -
        self.expected_bucket_owner = ::std::option::Option::Some(input.into());
   84         -
        self
   85         -
    }
   86         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
   87         -
    pub fn set_expected_bucket_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   88         -
        self.expected_bucket_owner = input;
   89         -
        self
   90         -
    }
   91         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
   92         -
    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {
   93         -
        &self.expected_bucket_owner
   94         -
    }
   95     74   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
   96     75   
    /// This field is required.
   97     76   
    pub fn intelligent_tiering_configuration(mut self, input: crate::types::IntelligentTieringConfiguration) -> Self {
   98     77   
        self.intelligent_tiering_configuration = ::std::option::Option::Some(input);
   99     78   
        self
  100     79   
    }
  101     80   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
  102     81   
    pub fn set_intelligent_tiering_configuration(mut self, input: ::std::option::Option<crate::types::IntelligentTieringConfiguration>) -> Self {
  103     82   
        self.intelligent_tiering_configuration = input;
  104     83   
        self
  105     84   
    }
  106     85   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
  107     86   
    pub fn get_intelligent_tiering_configuration(&self) -> &::std::option::Option<crate::types::IntelligentTieringConfiguration> {
  108     87   
        &self.intelligent_tiering_configuration
  109     88   
    }
  110     89   
    /// Consumes the builder and constructs a [`PutBucketIntelligentTieringConfigurationInput`](crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput).
  111     90   
    pub fn build(
  112     91   
        self,
  113     92   
    ) -> ::std::result::Result<
  114     93   
        crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput,
  115     94   
        ::aws_smithy_types::error::operation::BuildError,
  116     95   
    > {
  117     96   
        ::std::result::Result::Ok(
  118     97   
            crate::operation::put_bucket_intelligent_tiering_configuration::PutBucketIntelligentTieringConfigurationInput {
  119     98   
                bucket: self.bucket,
  120     99   
                id: self.id,
  121         -
                expected_bucket_owner: self.expected_bucket_owner,
  122    100   
                intelligent_tiering_configuration: self.intelligent_tiering_configuration,
  123    101   
            },
  124    102   
        )
  125    103   
    }
  126    104   
}

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

@@ -153,153 +211,197 @@
  173    173   
    }
  174    174   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
  175    175   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  176    176   
        self.inner = self.inner.set_id(input);
  177    177   
        self
  178    178   
    }
  179    179   
    /// <p>The ID used to identify the S3 Intelligent-Tiering configuration.</p>
  180    180   
    pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
  181    181   
        self.inner.get_id()
  182    182   
    }
  183         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
  184         -
    pub fn expected_bucket_owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  185         -
        self.inner = self.inner.expected_bucket_owner(input.into());
  186         -
        self
  187         -
    }
  188         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
  189         -
    pub fn set_expected_bucket_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  190         -
        self.inner = self.inner.set_expected_bucket_owner(input);
  191         -
        self
  192         -
    }
  193         -
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
  194         -
    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {
  195         -
        self.inner.get_expected_bucket_owner()
  196         -
    }
  197    183   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
  198    184   
    pub fn intelligent_tiering_configuration(mut self, input: crate::types::IntelligentTieringConfiguration) -> Self {
  199    185   
        self.inner = self.inner.intelligent_tiering_configuration(input);
  200    186   
        self
  201    187   
    }
  202    188   
    /// <p>Container for S3 Intelligent-Tiering configuration.</p>
  203    189   
    pub fn set_intelligent_tiering_configuration(mut self, input: ::std::option::Option<crate::types::IntelligentTieringConfiguration>) -> Self {
  204    190   
        self.inner = self.inner.set_intelligent_tiering_configuration(input);
  205    191   
        self
  206    192   
    }

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

@@ -1,1 +58,58 @@
   18     18   
        let mut fluent_builder = client.put_bucket_inventory_configuration();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `PutBucketInventoryConfiguration`.
   24     24   
///
   25     25   
/// <note>
   26     26   
/// <p>This operation is not supported for directory buckets.</p>
   27     27   
/// </note>
   28         -
/// <p>This implementation of the <code>PUT</code> action adds an S3 Inventory configuration (identified by the inventory ID) to the bucket. You can have up to 1,000 inventory configurations per bucket.</p>
          28  +
/// <p>This implementation of the <code>PUT</code> action adds an inventory configuration (identified by the inventory ID) to the bucket. You can have up to 1,000 inventory configurations per bucket.</p>
   29     29   
/// <p>Amazon S3 inventory generates inventories of the objects in the bucket on a daily or weekly basis, and the results are published to a flat file. The bucket that is inventoried is called the <i>source</i> bucket, and the bucket where the inventory flat file is stored is called the <i>destination</i> bucket. The <i>destination</i> bucket must be in the same Amazon Web Services Region as the <i>source</i> bucket.</p>
   30     30   
/// <p>When you configure an inventory for a <i>source</i> bucket, you specify the <i>destination</i> bucket where you want the inventory to be stored, and whether to generate the inventory daily or weekly. You can also configure what object metadata to include and whether to inventory all object versions or only current versions. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-inventory.html">Amazon S3 Inventory</a> in the Amazon S3 User Guide.</p><important>
   31     31   
/// <p>You must create a bucket policy on the <i>destination</i> bucket to grant permissions to Amazon S3 to write objects to the bucket in the defined location. For an example policy, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/example-bucket-policies.html#example-bucket-policies-use-case-9"> Granting Permissions for Amazon S3 Inventory and Storage Class Analysis</a>.</p>
   32     32   
/// </important>
   33     33   
/// <dl>
   34     34   
/// <dt>
   35     35   
/// Permissions
   36     36   
/// </dt>
   37     37   
/// <dd>
   38     38   
/// <p>To use this operation, you must have permission to perform the <code>s3:PutInventoryConfiguration</code> action. The bucket owner has this permission by default and can grant this permission to others.</p>

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

@@ -1,1 +70,67 @@
   15     15   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   16     16   
        >,
   17     17   
    > {
   18     18   
        let mut fluent_builder = client.put_bucket_logging();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `PutBucketLogging`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will discontinue support for creating new Email Grantee Access Control Lists (ACL). Email Grantee ACLs created prior to this date will continue to work and remain accessible through the Amazon Web Services Management Console, Command Line Interface (CLI), SDKs, and REST API. However, you will no longer be able to create new Email Grantee ACLs.</p>
   27         -
/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>
   28         -
/// </important> <note>
          25  +
/// <note>
   29     26   
/// <p>This operation is not supported for directory buckets.</p>
   30     27   
/// </note>
   31     28   
/// <p>Set the logging parameters for a bucket and to specify permissions for who can view and modify the logging parameters. All logs are saved to buckets in the same Amazon Web Services Region as the source bucket. To set the logging status of a bucket, you must be the bucket owner.</p>
   32     29   
/// <p>The bucket owner is automatically granted FULL_CONTROL to all logs. You use the <code>Grantee</code> request element to grant access to other people. The <code>Permissions</code> request element specifies the kind of access the grantee has to the logs.</p><important>
   33     30   
/// <p>If the target bucket for log delivery uses the bucket owner enforced setting for S3 Object Ownership, you can't use the <code>Grantee</code> request element to grant access to others. Permissions can only be granted using policies. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html#grant-log-delivery-permissions-general">Permissions for server access log delivery</a> in the <i>Amazon S3 User Guide</i>.</p>
   34     31   
/// </important>
   35     32   
/// <dl>
   36     33   
/// <dt>
   37     34   
/// Grantee Values
   38     35   
/// </dt>
   39     36   
/// <dd>
   40         -
/// <p>You can specify the person (grantee) to whom you're assigning access rights (by using request elements) in the following ways. For examples of how to specify these grantee values in JSON format, see the Amazon Web Services CLI example in <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html"> Enabling Amazon S3 server access logging</a> in the <i>Amazon S3 User Guide</i>.</p>
          37  +
/// <p>You can specify the person (grantee) to whom you're assigning access rights (by using request elements) in the following ways:</p>
   41     38   
/// <ul>
   42     39   
/// <li>
   43     40   
/// <p>By the person's ID:</p>
   44     41   
/// <p><code><grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
   45     42   
/// <id>
   46     43   
/// &lt;&gt;ID&lt;&gt;
   47     44   
/// </id>
   48     45   
/// <displayname>
   49     46   
/// &lt;&gt;GranteesEmail&lt;&gt;
   50     47   
/// </displayname>

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

@@ -157,157 +217,216 @@
  177    177   
                            request.headers_mut().insert("x-amz-sdk-checksum-algorithm", "CRC32");
  178    178   
                        }
  179    179   
                        _ => {}
  180    180   
                    }
  181    181   
  182    182   
                    // We return a bool indicating if the user did set the checksum value, if they did
  183    183   
                    // we can short circuit and exit the interceptor early.
  184    184   
                    Ok(user_set_checksum_value)
  185    185   
                },
  186    186   
            ))
  187         -
            .with_interceptor(crate::aws_chunked::AwsChunkedContentEncodingInterceptor)
  188    187   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  189    188   
                crate::operation::put_object::PutObjectError,
  190    189   
            >::new())
  191    190   
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  192    191   
                crate::operation::put_object::PutObjectError,
  193    192   
            >::new())
  194    193   
            .with_retry_classifier(
  195    194   
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::put_object::PutObjectError>::builder()
  196    195   
                    .transient_errors({
  197    196   
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
@@ -258,257 +325,320 @@
  278    277   
                input: &crate::operation::put_object::PutObjectInput,
  279    278   
                builder: ::http::request::Builder,
  280    279   
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  281    280   
                let mut uri = ::std::string::String::new();
  282    281   
                uri_base(input, &mut uri)?;
  283    282   
                uri_query(input, &mut uri)?;
  284    283   
                let builder = crate::protocol_serde::shape_put_object::ser_put_object_headers(input, builder)?;
  285    284   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  286    285   
            }
  287    286   
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  288         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
  289    287   
            builder
  290    288   
        };
  291         -
        let body = crate::protocol_serde::shape_put_object_input::ser_body_http_payload(input.body)?.into_inner();
  292         -
        if let Some(content_length) = body.content_length() {
  293         -
            let content_length = content_length.to_string();
  294         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
  295         -
        }
         289  +
        let body = ::aws_smithy_types::body::SdkBody::from("");
         290  +
  296    291   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  297    292   
    }
  298    293   
}
  299    294   
#[derive(Debug)]
  300    295   
struct PutObjectEndpointParamsInterceptor;
  301    296   
  302    297   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutObjectEndpointParamsInterceptor {
  303    298   
    fn name(&self) -> &'static str {
  304    299   
        "PutObjectEndpointParamsInterceptor"
  305    300   
    }
@@ -361,356 +452,415 @@
  381    376   
            .send()
  382    377   
            .await;
  383    378   
        let _ = dbg!(result);
  384    379   
        let http_request = request_receiver.expect_request();
  385    380   
        let expected_headers = [("content-type", "text/html")];
  386    381   
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  387    382   
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  388    383   
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  389    384   
        ::pretty_assertions::assert_eq!(uri.path(), "/test-key", "path was incorrect");
  390    385   
    }
  391         -
  392         -
    /// This test validates that if a content-length is specified, that only one content-length header is sent
  393         -
    /// Test ID: DontSendDuplicateContentLength
  394         -
    #[::tokio::test]
  395         -
    #[::tracing_test::traced_test]
  396         -
    async fn dont_send_duplicate_content_length_request() {
  397         -
        let (http_client, request_receiver) = ::aws_smithy_http_client::test_util::capture_request(None);
  398         -
        let config_builder = crate::config::Config::builder().with_test_defaults().endpoint_url("https://example.com");
  399         -
        let config_builder = config_builder.region(::aws_types::region::Region::new("us-east-1"));
  400         -
        let mut config_builder = config_builder;
  401         -
        config_builder.set_region(Some(crate::config::Region::new("us-east-1")));
  402         -
  403         -
        let config = config_builder.http_client(http_client).build();
  404         -
        let client = crate::Client::from_conf(config);
  405         -
        let result = client
  406         -
            .put_object()
  407         -
            .set_bucket(::std::option::Option::Some("test-bucket".to_owned()))
  408         -
            .set_key(::std::option::Option::Some("test-key".to_owned()))
  409         -
            .set_content_length(::std::option::Option::Some(2))
  410         -
            .set_body(::std::option::Option::Some(::aws_smithy_types::byte_stream::ByteStream::from_static(
  411         -
                b"ab",
  412         -
            )))
  413         -
            .send()
  414         -
            .await;
  415         -
        let _ = dbg!(result);
  416         -
        let http_request = request_receiver.expect_request();
  417         -
        let expected_headers = [("content-length", "2")];
  418         -
        ::aws_smithy_protocol_test::assert_ok(::aws_smithy_protocol_test::validate_headers(http_request.headers(), expected_headers));
  419         -
        let uri: ::http::Uri = http_request.uri().parse().expect("invalid URI sent");
  420         -
        ::pretty_assertions::assert_eq!(http_request.method(), "PUT", "method was incorrect");
  421         -
        ::pretty_assertions::assert_eq!(uri.path(), "/test-key", "path was incorrect");
  422         -
    }
  423    386   
}
  424    387   
  425    388   
/// Error type for the `PutObjectError` operation.
  426    389   
#[non_exhaustive]
  427    390   
#[derive(::std::fmt::Debug)]
  428    391   
pub enum PutObjectError {
  429    392   
    /// <p>The existing object was created with a different encryption type. Subsequent write requests must include the appropriate encryption parameters in the request or while creating the session.</p>
  430    393   
    EncryptionTypeMismatch(crate::types::error::EncryptionTypeMismatch),
  431    394   
    /// <p>You may receive this error in multiple cases. Depending on the reason for the error, you may receive one of the messages below:</p>
  432    395   
    /// <ul>

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object/_put_object_input.rs

@@ -1,1 +47,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
#[allow(missing_docs)] // documentation missing in model
    3      3   
#[non_exhaustive]
           4  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq)]
    4      5   
pub struct PutObjectInput {
    5      6   
    /// <p>The canned ACL to apply to the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html#CannedACL">Canned ACL</a> in the <i>Amazon S3 User Guide</i>.</p>
    6      7   
    /// <p>When adding a new object, you can use headers to grant ACL-based permissions to individual Amazon Web Services accounts or to predefined groups defined by Amazon S3. These permissions are then added to the ACL on the object. By default, all objects are private. Only the owner has full access control. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-overview.html">Access Control List (ACL) Overview</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/acl-using-rest-api.html">Managing ACLs Using the REST API</a> in the <i>Amazon S3 User Guide</i>.</p>
    7      8   
    /// <p>If the bucket that you're uploading objects to uses the bucket owner enforced setting for S3 Object Ownership, ACLs are disabled and no longer affect permissions. Buckets that use this setting only accept PUT requests that don't specify an ACL or PUT requests that specify bucket owner full control ACLs, such as the <code>bucket-owner-full-control</code> canned ACL or an equivalent form of this ACL expressed in the XML format. PUT requests that contain other ACLs (for example, custom grants to certain Amazon Web Services accounts) fail and return a <code>400</code> error with the error code <code>AccessControlListNotSupported</code>. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/about-object-ownership.html"> Controlling ownership of objects and disabling ACLs</a> in the <i>Amazon S3 User Guide</i>.</p><note>
    8      9   
    /// <ul>
    9     10   
    /// <li>
   10     11   
    /// <p>This functionality is not supported for directory buckets.</p></li>
   11     12   
    /// <li>
   12     13   
    /// <p>This functionality is not supported for Amazon S3 on Outposts.</p></li>
   13     14   
    /// </ul>
   14     15   
    /// </note>
   15     16   
    pub acl: ::std::option::Option<crate::types::ObjectCannedAcl>,
   16         -
    /// <p>Object data.</p>
   17         -
    pub body: ::aws_smithy_types::byte_stream::ByteStream,
   18     17   
    /// <p>The bucket name to which the PUT action was initiated.</p>
   19     18   
    /// <p><b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Zone (Availability Zone or Local Zone). Bucket names must follow the format <code> <i>bucket-base-name</i>--<i>zone-id</i>--x-s3</code> (for example, <code> <i>amzn-s3-demo-bucket</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
   20     19   
    /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   21     20   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   22     21   
    /// </note>
   23     22   
    /// <p><b>S3 on Outposts</b> - When you use this action with S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code> <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts, the destination bucket must be the Outposts access point ARN or the access point alias. For more information about S3 on Outposts, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
   24     23   
    pub bucket: ::std::option::Option<::std::string::String>,
   25     24   
    /// <p>Can be used to specify caching behavior along the request/reply chain. For more information, see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9">http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9</a>.</p>
   26     25   
    pub cache_control: ::std::option::Option<::std::string::String>,
   27     26   
    /// <p>Specifies presentational information for the object. For more information, see <a href="https://www.rfc-editor.org/rfc/rfc6266#section-4">https://www.rfc-editor.org/rfc/rfc6266#section-4</a>.</p>
@@ -99,98 +169,166 @@
  119    118   
    /// </note>
  120    119   
    pub grant_write_acp: ::std::option::Option<::std::string::String>,
  121    120   
    /// <p>Object key for which the PUT action was initiated.</p>
  122    121   
    pub key: ::std::option::Option<::std::string::String>,
  123    122   
    /// <p>Specifies the offset for appending data to existing objects in bytes. The offset must be equal to the size of the existing object being appended to. If no object exists, setting this header to 0 will create a new object.</p><note>
  124    123   
    /// <p>This functionality is only supported for objects in the Amazon S3 Express One Zone storage class in directory buckets.</p>
  125    124   
    /// </note>
  126    125   
    pub write_offset_bytes: ::std::option::Option<i64>,
  127    126   
    /// <p>A map of metadata to store with the object in S3.</p>
  128    127   
    pub metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
  129         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
         128  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  130    129   
    /// <ul>
  131    130   
    /// <li>
  132    131   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
  133    132   
    /// <li>
  134    133   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
  135    134   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
  136    135   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
  137    136   
    /// </note></li>
  138         -
    /// <li>
  139         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
  140    137   
    /// </ul>
  141    138   
    pub server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
  142    139   
    /// <p>By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage Classes</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  143    140   
    /// <ul>
  144    141   
    /// <li>
  145    142   
    /// <p>Directory buckets only support <code>EXPRESS_ONEZONE</code> (the S3 Express One Zone storage class) in Availability Zones and <code>ONEZONE_IA</code> (the S3 One Zone-Infrequent Access storage class) in Dedicated Local Zones.</p></li>
  146    143   
    /// <li>
  147    144   
    /// <p>Amazon S3 on Outposts only uses the OUTPOSTS Storage Class.</p></li>
  148    145   
    /// </ul>
  149    146   
    /// </note>
@@ -191,188 +254,247 @@
  211    208   
    /// <ul>
  212    209   
    /// <li>
  213    210   
    /// <p>This functionality is not supported for directory buckets.</p></li>
  214    211   
    /// <li>
  215    212   
    /// <p>This functionality is not supported for Amazon S3 on Outposts.</p></li>
  216    213   
    /// </ul>
  217    214   
    /// </note>
  218    215   
    pub fn acl(&self) -> ::std::option::Option<&crate::types::ObjectCannedAcl> {
  219    216   
        self.acl.as_ref()
  220    217   
    }
  221         -
    /// <p>Object data.</p>
  222         -
    pub fn body(&self) -> &::aws_smithy_types::byte_stream::ByteStream {
  223         -
        &self.body
  224         -
    }
  225    218   
    /// <p>The bucket name to which the PUT action was initiated.</p>
  226    219   
    /// <p><b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Zone (Availability Zone or Local Zone). Bucket names must follow the format <code> <i>bucket-base-name</i>--<i>zone-id</i>--x-s3</code> (for example, <code> <i>amzn-s3-demo-bucket</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  227    220   
    /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  228    221   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  229    222   
    /// </note>
  230    223   
    /// <p><b>S3 on Outposts</b> - When you use this action with S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code> <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts, the destination bucket must be the Outposts access point ARN or the access point alias. For more information about S3 on Outposts, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
  231    224   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
  232    225   
        self.bucket.as_deref()
  233    226   
    }
  234    227   
    /// <p>Can be used to specify caching behavior along the request/reply chain. For more information, see <a href="http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9">http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9</a>.</p>
@@ -354,347 +424,415 @@
  374    367   
    /// <p>Specifies the offset for appending data to existing objects in bytes. The offset must be equal to the size of the existing object being appended to. If no object exists, setting this header to 0 will create a new object.</p><note>
  375    368   
    /// <p>This functionality is only supported for objects in the Amazon S3 Express One Zone storage class in directory buckets.</p>
  376    369   
    /// </note>
  377    370   
    pub fn write_offset_bytes(&self) -> ::std::option::Option<i64> {
  378    371   
        self.write_offset_bytes
  379    372   
    }
  380    373   
    /// <p>A map of metadata to store with the object in S3.</p>
  381    374   
    pub fn metadata(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
  382    375   
        self.metadata.as_ref()
  383    376   
    }
  384         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
         377  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  385    378   
    /// <ul>
  386    379   
    /// <li>
  387    380   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
  388    381   
    /// <li>
  389    382   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
  390    383   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
  391    384   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
  392    385   
    /// </note></li>
  393         -
    /// <li>
  394         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
  395    386   
    /// </ul>
  396    387   
    pub fn server_side_encryption(&self) -> ::std::option::Option<&crate::types::ServerSideEncryption> {
  397    388   
        self.server_side_encryption.as_ref()
  398    389   
    }
  399    390   
    /// <p>By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage Classes</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  400    391   
    /// <ul>
  401    392   
    /// <li>
  402    393   
    /// <p>Directory buckets only support <code>EXPRESS_ONEZONE</code> (the S3 Express One Zone storage class) in Availability Zones and <code>ONEZONE_IA</code> (the S3 One Zone-Infrequent Access storage class) in Dedicated Local Zones.</p></li>
  403    394   
    /// <li>
  404    395   
    /// <p>Amazon S3 on Outposts only uses the OUTPOSTS Storage Class.</p></li>
@@ -466,457 +581,570 @@
  486    477   
    }
  487    478   
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
  488    479   
    pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
  489    480   
        self.expected_bucket_owner.as_deref()
  490    481   
    }
  491    482   
}
  492    483   
impl ::std::fmt::Debug for PutObjectInput {
  493    484   
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
  494    485   
        let mut formatter = f.debug_struct("PutObjectInput");
  495    486   
        formatter.field("acl", &self.acl);
  496         -
        formatter.field("body", &self.body);
  497    487   
        formatter.field("bucket", &self.bucket);
  498    488   
        formatter.field("cache_control", &self.cache_control);
  499    489   
        formatter.field("content_disposition", &self.content_disposition);
  500    490   
        formatter.field("content_encoding", &self.content_encoding);
  501    491   
        formatter.field("content_language", &self.content_language);
  502    492   
        formatter.field("content_length", &self.content_length);
  503    493   
        formatter.field("content_md5", &self.content_md5);
  504    494   
        formatter.field("content_type", &self.content_type);
  505    495   
        formatter.field("checksum_algorithm", &self.checksum_algorithm);
  506    496   
        formatter.field("checksum_crc32", &self.checksum_crc32);
  507    497   
        formatter.field("checksum_crc32_c", &self.checksum_crc32_c);
  508    498   
        formatter.field("checksum_crc64_nvme", &self.checksum_crc64_nvme);
  509    499   
        formatter.field("checksum_sha1", &self.checksum_sha1);
  510    500   
        formatter.field("checksum_sha256", &self.checksum_sha256);
  511    501   
        formatter.field("expires", &self.expires);
  512    502   
        formatter.field("if_match", &self.if_match);
  513    503   
        formatter.field("if_none_match", &self.if_none_match);
  514    504   
        formatter.field("grant_full_control", &self.grant_full_control);
  515    505   
        formatter.field("grant_read", &self.grant_read);
  516    506   
        formatter.field("grant_read_acp", &self.grant_read_acp);
  517    507   
        formatter.field("grant_write_acp", &self.grant_write_acp);
  518    508   
        formatter.field("key", &self.key);
  519    509   
        formatter.field("write_offset_bytes", &self.write_offset_bytes);
  520    510   
        formatter.field("metadata", &self.metadata);
  521    511   
        formatter.field("server_side_encryption", &self.server_side_encryption);
  522    512   
        formatter.field("storage_class", &self.storage_class);
  523    513   
        formatter.field("website_redirect_location", &self.website_redirect_location);
  524    514   
        formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
  525    515   
        formatter.field("sse_customer_key", &"*** Sensitive Data Redacted ***");
  526    516   
        formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
  527    517   
        formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
  528    518   
        formatter.field("ssekms_encryption_context", &"*** Sensitive Data Redacted ***");
  529    519   
        formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
  530    520   
        formatter.field("request_payer", &self.request_payer);
  531    521   
        formatter.field("tagging", &self.tagging);
  532    522   
        formatter.field("object_lock_mode", &self.object_lock_mode);
  533    523   
        formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
  534    524   
        formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
  535    525   
        formatter.field("expected_bucket_owner", &self.expected_bucket_owner);
  536    526   
        formatter.finish()
  537    527   
    }
  538    528   
}
  539    529   
impl PutObjectInput {
  540    530   
    /// Creates a new builder-style object to manufacture [`PutObjectInput`](crate::operation::put_object::PutObjectInput).
  541    531   
    pub fn builder() -> crate::operation::put_object::builders::PutObjectInputBuilder {
  542    532   
        crate::operation::put_object::builders::PutObjectInputBuilder::default()
  543    533   
    }
  544    534   
}
  545    535   
  546    536   
/// A builder for [`PutObjectInput`](crate::operation::put_object::PutObjectInput).
  547         -
#[derive(::std::default::Default)]
         537  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  548    538   
#[non_exhaustive]
  549    539   
pub struct PutObjectInputBuilder {
  550    540   
    pub(crate) acl: ::std::option::Option<crate::types::ObjectCannedAcl>,
  551         -
    pub(crate) body: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>,
  552    541   
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
  553    542   
    pub(crate) cache_control: ::std::option::Option<::std::string::String>,
  554    543   
    pub(crate) content_disposition: ::std::option::Option<::std::string::String>,
  555    544   
    pub(crate) content_encoding: ::std::option::Option<::std::string::String>,
  556    545   
    pub(crate) content_language: ::std::option::Option<::std::string::String>,
  557    546   
    pub(crate) content_length: ::std::option::Option<i64>,
  558    547   
    pub(crate) content_md5: ::std::option::Option<::std::string::String>,
  559    548   
    pub(crate) content_type: ::std::option::Option<::std::string::String>,
  560    549   
    pub(crate) checksum_algorithm: ::std::option::Option<crate::types::ChecksumAlgorithm>,
  561    550   
    pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
@@ -604,593 +677,652 @@
  624    613   
    /// <ul>
  625    614   
    /// <li>
  626    615   
    /// <p>This functionality is not supported for directory buckets.</p></li>
  627    616   
    /// <li>
  628    617   
    /// <p>This functionality is not supported for Amazon S3 on Outposts.</p></li>
  629    618   
    /// </ul>
  630    619   
    /// </note>
  631    620   
    pub fn get_acl(&self) -> &::std::option::Option<crate::types::ObjectCannedAcl> {
  632    621   
        &self.acl
  633    622   
    }
  634         -
    /// <p>Object data.</p>
  635         -
    pub fn body(mut self, input: ::aws_smithy_types::byte_stream::ByteStream) -> Self {
  636         -
        self.body = ::std::option::Option::Some(input);
  637         -
        self
  638         -
    }
  639         -
    /// <p>Object data.</p>
  640         -
    pub fn set_body(mut self, input: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>) -> Self {
  641         -
        self.body = input;
  642         -
        self
  643         -
    }
  644         -
    /// <p>Object data.</p>
  645         -
    pub fn get_body(&self) -> &::std::option::Option<::aws_smithy_types::byte_stream::ByteStream> {
  646         -
        &self.body
  647         -
    }
  648    623   
    /// <p>The bucket name to which the PUT action was initiated.</p>
  649    624   
    /// <p><b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Zone (Availability Zone or Local Zone). Bucket names must follow the format <code> <i>bucket-base-name</i>--<i>zone-id</i>--x-s3</code> (for example, <code> <i>amzn-s3-demo-bucket</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  650    625   
    /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  651    626   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  652    627   
    /// </note>
  653    628   
    /// <p><b>S3 on Outposts</b> - When you use this action with S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code> <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts, the destination bucket must be the Outposts access point ARN or the access point alias. For more information about S3 on Outposts, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
  654    629   
    /// This field is required.
  655    630   
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  656    631   
        self.bucket = ::std::option::Option::Some(input.into());
  657    632   
        self
@@ -1151,1126 +1253,1222 @@
 1171   1146   
    }
 1172   1147   
    /// <p>A map of metadata to store with the object in S3.</p>
 1173   1148   
    pub fn set_metadata(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
 1174   1149   
        self.metadata = input;
 1175   1150   
        self
 1176   1151   
    }
 1177   1152   
    /// <p>A map of metadata to store with the object in S3.</p>
 1178   1153   
    pub fn get_metadata(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
 1179   1154   
        &self.metadata
 1180   1155   
    }
 1181         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
        1156  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
 1182   1157   
    /// <ul>
 1183   1158   
    /// <li>
 1184   1159   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
 1185   1160   
    /// <li>
 1186   1161   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
 1187   1162   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
 1188   1163   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
 1189   1164   
    /// </note></li>
 1190         -
    /// <li>
 1191         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
 1192   1165   
    /// </ul>
 1193   1166   
    pub fn server_side_encryption(mut self, input: crate::types::ServerSideEncryption) -> Self {
 1194   1167   
        self.server_side_encryption = ::std::option::Option::Some(input);
 1195   1168   
        self
 1196   1169   
    }
 1197         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
        1170  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
 1198   1171   
    /// <ul>
 1199   1172   
    /// <li>
 1200   1173   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
 1201   1174   
    /// <li>
 1202   1175   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
 1203   1176   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
 1204   1177   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
 1205   1178   
    /// </note></li>
 1206         -
    /// <li>
 1207         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
 1208   1179   
    /// </ul>
 1209   1180   
    pub fn set_server_side_encryption(mut self, input: ::std::option::Option<crate::types::ServerSideEncryption>) -> Self {
 1210   1181   
        self.server_side_encryption = input;
 1211   1182   
        self
 1212   1183   
    }
 1213         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
        1184  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
 1214   1185   
    /// <ul>
 1215   1186   
    /// <li>
 1216   1187   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
 1217   1188   
    /// <li>
 1218   1189   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
 1219   1190   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
 1220   1191   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
 1221   1192   
    /// </note></li>
 1222         -
    /// <li>
 1223         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
 1224   1193   
    /// </ul>
 1225   1194   
    pub fn get_server_side_encryption(&self) -> &::std::option::Option<crate::types::ServerSideEncryption> {
 1226   1195   
        &self.server_side_encryption
 1227   1196   
    }
 1228   1197   
    /// <p>By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage Classes</a> in the <i>Amazon S3 User Guide</i>.</p><note>
 1229   1198   
    /// <ul>
 1230   1199   
    /// <li>
 1231   1200   
    /// <p>Directory buckets only support <code>EXPRESS_ONEZONE</code> (the S3 Express One Zone storage class) in Availability Zones and <code>ONEZONE_IA</code> (the S3 One Zone-Infrequent Access storage class) in Dedicated Local Zones.</p></li>
 1232   1201   
    /// <li>
 1233   1202   
    /// <p>Amazon S3 on Outposts only uses the OUTPOSTS Storage Class.</p></li>
@@ -1506,1475 +1613,1580 @@
 1526   1495   
        self
 1527   1496   
    }
 1528   1497   
    /// <p>The account ID of the expected bucket owner. If the account ID that you provide does not match the actual owner of the bucket, the request fails with the HTTP status code <code>403 Forbidden</code> (access denied).</p>
 1529   1498   
    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {
 1530   1499   
        &self.expected_bucket_owner
 1531   1500   
    }
 1532   1501   
    /// Consumes the builder and constructs a [`PutObjectInput`](crate::operation::put_object::PutObjectInput).
 1533   1502   
    pub fn build(self) -> ::std::result::Result<crate::operation::put_object::PutObjectInput, ::aws_smithy_types::error::operation::BuildError> {
 1534   1503   
        ::std::result::Result::Ok(crate::operation::put_object::PutObjectInput {
 1535   1504   
            acl: self.acl,
 1536         -
            body: self.body.unwrap_or_default(),
 1537   1505   
            bucket: self.bucket,
 1538   1506   
            cache_control: self.cache_control,
 1539   1507   
            content_disposition: self.content_disposition,
 1540   1508   
            content_encoding: self.content_encoding,
 1541   1509   
            content_language: self.content_language,
 1542   1510   
            content_length: self.content_length,
 1543   1511   
            content_md5: self.content_md5,
 1544   1512   
            content_type: self.content_type,
 1545   1513   
            checksum_algorithm: self.checksum_algorithm,
 1546   1514   
            checksum_crc32: self.checksum_crc32,
 1547   1515   
            checksum_crc32_c: self.checksum_crc32_c,
 1548   1516   
            checksum_crc64_nvme: self.checksum_crc64_nvme,
 1549   1517   
            checksum_sha1: self.checksum_sha1,
 1550   1518   
            checksum_sha256: self.checksum_sha256,
 1551   1519   
            expires: self.expires,
 1552   1520   
            if_match: self.if_match,
 1553   1521   
            if_none_match: self.if_none_match,
 1554   1522   
            grant_full_control: self.grant_full_control,
 1555   1523   
            grant_read: self.grant_read,
 1556   1524   
            grant_read_acp: self.grant_read_acp,
 1557   1525   
            grant_write_acp: self.grant_write_acp,
 1558   1526   
            key: self.key,
 1559   1527   
            write_offset_bytes: self.write_offset_bytes,
 1560   1528   
            metadata: self.metadata,
 1561   1529   
            server_side_encryption: self.server_side_encryption,
 1562   1530   
            storage_class: self.storage_class,
 1563   1531   
            website_redirect_location: self.website_redirect_location,
 1564   1532   
            sse_customer_algorithm: self.sse_customer_algorithm,
 1565   1533   
            sse_customer_key: self.sse_customer_key,
 1566   1534   
            sse_customer_key_md5: self.sse_customer_key_md5,
 1567   1535   
            ssekms_key_id: self.ssekms_key_id,
 1568   1536   
            ssekms_encryption_context: self.ssekms_encryption_context,
 1569   1537   
            bucket_key_enabled: self.bucket_key_enabled,
 1570   1538   
            request_payer: self.request_payer,
 1571   1539   
            tagging: self.tagging,
 1572   1540   
            object_lock_mode: self.object_lock_mode,
 1573   1541   
            object_lock_retain_until_date: self.object_lock_retain_until_date,
 1574   1542   
            object_lock_legal_hold_status: self.object_lock_legal_hold_status,
 1575   1543   
            expected_bucket_owner: self.expected_bucket_owner,
 1576   1544   
        })
 1577   1545   
    }
 1578   1546   
}
 1579   1547   
impl ::std::fmt::Debug for PutObjectInputBuilder {
 1580   1548   
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
 1581   1549   
        let mut formatter = f.debug_struct("PutObjectInputBuilder");
 1582   1550   
        formatter.field("acl", &self.acl);
 1583         -
        formatter.field("body", &self.body);
 1584   1551   
        formatter.field("bucket", &self.bucket);
 1585   1552   
        formatter.field("cache_control", &self.cache_control);
 1586   1553   
        formatter.field("content_disposition", &self.content_disposition);
 1587   1554   
        formatter.field("content_encoding", &self.content_encoding);
 1588   1555   
        formatter.field("content_language", &self.content_language);
 1589   1556   
        formatter.field("content_length", &self.content_length);
 1590   1557   
        formatter.field("content_md5", &self.content_md5);
 1591   1558   
        formatter.field("content_type", &self.content_type);
 1592   1559   
        formatter.field("checksum_algorithm", &self.checksum_algorithm);
 1593   1560   
        formatter.field("checksum_crc32", &self.checksum_crc32);

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/put_object/_put_object_output.rs

@@ -1,1 +58,56 @@
   16     16   
    /// <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>
   17     17   
    pub checksum_crc32_c: ::std::option::Option<::std::string::String>,
   18     18   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This header is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if it was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). 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">Checking object integrity in the Amazon S3 User Guide</a>.</p>
   19     19   
    pub checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
   20     20   
    /// <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>
   21     21   
    pub checksum_sha1: ::std::option::Option<::std::string::String>,
   22     22   
    /// <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>
   23     23   
    pub checksum_sha256: ::std::option::Option<::std::string::String>,
   24     24   
    /// <p>This header specifies the checksum type of the object, which determines how part-level checksums are combined to create an object-level checksum for multipart objects. For <code>PutObject</code> uploads, the checksum type is always <code>FULL_OBJECT</code>. You can use this header as a data integrity check to verify that the checksum type that is received is the same checksum that was specified. 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>
   25     25   
    pub checksum_type: ::std::option::Option<crate::types::ChecksumType>,
   26         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
   27         -
    /// <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>
   28         -
    /// </note>
          26  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3.</p>
   29     27   
    pub server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
   30     28   
    /// <p>Version ID of the object.</p>
   31     29   
    /// <p>If you enable versioning for a bucket, Amazon S3 automatically generates a unique version ID for the object being stored. Amazon S3 returns this ID in the response. When you enable versioning for a bucket, if Amazon S3 receives multiple write requests for the same object simultaneously, it stores all of the objects. For more information about versioning, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/AddingObjectstoVersioningEnabledBuckets.html">Adding Objects to Versioning-Enabled Buckets</a> in the <i>Amazon S3 User Guide</i>. For information about returning the versioning state of a bucket, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketVersioning.html">GetBucketVersioning</a>.</p><note>
   32     30   
    /// <p>This functionality is not supported for directory buckets.</p>
   33     31   
    /// </note>
   34     32   
    pub version_id: ::std::option::Option<::std::string::String>,
   35     33   
    /// <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>
   36     34   
    /// <p>This functionality is not supported for directory buckets.</p>
   37     35   
    /// </note>
   38     36   
    pub sse_customer_algorithm: ::std::option::Option<::std::string::String>,
@@ -67,65 +129,125 @@
   87     85   
        self.checksum_sha1.as_deref()
   88     86   
    }
   89     87   
    /// <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>
   90     88   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   91     89   
        self.checksum_sha256.as_deref()
   92     90   
    }
   93     91   
    /// <p>This header specifies the checksum type of the object, which determines how part-level checksums are combined to create an object-level checksum for multipart objects. For <code>PutObject</code> uploads, the checksum type is always <code>FULL_OBJECT</code>. You can use this header as a data integrity check to verify that the checksum type that is received is the same checksum that was specified. 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>
   94     92   
    pub fn checksum_type(&self) -> ::std::option::Option<&crate::types::ChecksumType> {
   95     93   
        self.checksum_type.as_ref()
   96     94   
    }
   97         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
   98         -
    /// <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>
   99         -
    /// </note>
          95  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3.</p>
  100     96   
    pub fn server_side_encryption(&self) -> ::std::option::Option<&crate::types::ServerSideEncryption> {
  101     97   
        self.server_side_encryption.as_ref()
  102     98   
    }
  103     99   
    /// <p>Version ID of the object.</p>
  104    100   
    /// <p>If you enable versioning for a bucket, Amazon S3 automatically generates a unique version ID for the object being stored. Amazon S3 returns this ID in the response. When you enable versioning for a bucket, if Amazon S3 receives multiple write requests for the same object simultaneously, it stores all of the objects. For more information about versioning, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/AddingObjectstoVersioningEnabledBuckets.html">Adding Objects to Versioning-Enabled Buckets</a> in the <i>Amazon S3 User Guide</i>. For information about returning the versioning state of a bucket, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketVersioning.html">GetBucketVersioning</a>.</p><note>
  105    101   
    /// <p>This functionality is not supported for directory buckets.</p>
  106    102   
    /// </note>
  107    103   
    pub fn version_id(&self) -> ::std::option::Option<&str> {
  108    104   
        self.version_id.as_deref()
  109    105   
    }
@@ -308,304 +384,374 @@
  328    324   
    }
  329    325   
    /// <p>This header specifies the checksum type of the object, which determines how part-level checksums are combined to create an object-level checksum for multipart objects. For <code>PutObject</code> uploads, the checksum type is always <code>FULL_OBJECT</code>. You can use this header as a data integrity check to verify that the checksum type that is received is the same checksum that was specified. 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>
  330    326   
    pub fn set_checksum_type(mut self, input: ::std::option::Option<crate::types::ChecksumType>) -> Self {
  331    327   
        self.checksum_type = input;
  332    328   
        self
  333    329   
    }
  334    330   
    /// <p>This header specifies the checksum type of the object, which determines how part-level checksums are combined to create an object-level checksum for multipart objects. For <code>PutObject</code> uploads, the checksum type is always <code>FULL_OBJECT</code>. You can use this header as a data integrity check to verify that the checksum type that is received is the same checksum that was specified. 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>
  335    331   
    pub fn get_checksum_type(&self) -> &::std::option::Option<crate::types::ChecksumType> {
  336    332   
        &self.checksum_type
  337    333   
    }
  338         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  339         -
    /// <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>
  340         -
    /// </note>
         334  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3.</p>
  341    335   
    pub fn server_side_encryption(mut self, input: crate::types::ServerSideEncryption) -> Self {
  342    336   
        self.server_side_encryption = ::std::option::Option::Some(input);
  343    337   
        self
  344    338   
    }
  345         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  346         -
    /// <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>
  347         -
    /// </note>
         339  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3.</p>
  348    340   
    pub fn set_server_side_encryption(mut self, input: ::std::option::Option<crate::types::ServerSideEncryption>) -> Self {
  349    341   
        self.server_side_encryption = input;
  350    342   
        self
  351    343   
    }
  352         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  353         -
    /// <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>
  354         -
    /// </note>
         344  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3.</p>
  355    345   
    pub fn get_server_side_encryption(&self) -> &::std::option::Option<crate::types::ServerSideEncryption> {
  356    346   
        &self.server_side_encryption
  357    347   
    }
  358    348   
    /// <p>Version ID of the object.</p>
  359    349   
    /// <p>If you enable versioning for a bucket, Amazon S3 automatically generates a unique version ID for the object being stored. Amazon S3 returns this ID in the response. When you enable versioning for a bucket, if Amazon S3 receives multiple write requests for the same object simultaneously, it stores all of the objects. For more information about versioning, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/AddingObjectstoVersioningEnabledBuckets.html">Adding Objects to Versioning-Enabled Buckets</a> in the <i>Amazon S3 User Guide</i>. For information about returning the versioning state of a bucket, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketVersioning.html">GetBucketVersioning</a>.</p><note>
  360    350   
    /// <p>This functionality is not supported for directory buckets.</p>
  361    351   
    /// </note>
  362    352   
    pub fn version_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  363    353   
        self.version_id = ::std::option::Option::Some(input.into());
  364    354   
        self

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

@@ -1,1 +58,54 @@
   15     15   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   16     16   
        >,
   17     17   
    > {
   18     18   
        let mut fluent_builder = client.put_object();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `PutObject`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will discontinue support for creating new Email Grantee Access Control Lists (ACL). Email Grantee ACLs created prior to this date will continue to work and remain accessible through the Amazon Web Services Management Console, Command Line Interface (CLI), SDKs, and REST API. However, you will no longer be able to create new Email Grantee ACLs.</p>
   27         -
/// <p>This change affects the following Amazon Web Services Regions: US East (N. Virginia) Region, US West (N. California) Region, US West (Oregon) Region, Asia Pacific (Singapore) Region, Asia Pacific (Sydney) Region, Asia Pacific (Tokyo) Region, Europe (Ireland) Region, and South America (São Paulo) Region.</p>
   28         -
/// </important>
   29     25   
/// <p>Adds an object to a bucket.</p><note>
   30     26   
/// <ul>
   31     27   
/// <li>
   32     28   
/// <p>Amazon S3 never adds partial objects; if you receive a success response, Amazon S3 added the entire object to the bucket. You cannot use <code>PutObject</code> to only update a single piece of metadata for an existing object. You must put the entire object with updated metadata if you want to update some values.</p></li>
   33     29   
/// <li>
   34     30   
/// <p>If your bucket uses the bucket owner enforced setting for Object Ownership, ACLs are disabled and no longer affect permissions. All objects written to the bucket by any account will be owned by the bucket owner.</p></li>
   35     31   
/// <li>
   36     32   
/// <p><b>Directory buckets</b> - For directory buckets, you must make requests for this API operation to the Zonal endpoint. These endpoints support virtual-hosted-style requests in the format <code>https://<i>amzn-s3-demo-bucket</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com/<i>key-name</i> </code>. Path-style requests are not supported. For more information about endpoints in Availability Zones, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/endpoint-directory-buckets-AZ.html">Regional and Zonal endpoints for directory buckets in Availability Zones</a> in the <i>Amazon S3 User Guide</i>. For more information about endpoints in Local Zones, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-lzs-for-directory-buckets.html">Concepts for directory buckets in Local Zones</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   37     33   
/// </ul>
   38     34   
/// </note>
@@ -72,68 +132,128 @@
   92     88   
/// <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>
   93     89   
/// </dd>
   94     90   
/// </dl>
   95     91   
/// <p>For more information about related Amazon S3 APIs, see the following:</p>
   96     92   
/// <ul>
   97     93   
/// <li>
   98     94   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html">CopyObject</a></p></li>
   99     95   
/// <li>
  100     96   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html">DeleteObject</a></p></li>
  101     97   
/// </ul>
  102         -
#[derive(::std::fmt::Debug)]
          98  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
  103     99   
pub struct PutObjectFluentBuilder {
  104    100   
    handle: ::std::sync::Arc<crate::client::Handle>,
  105    101   
    inner: crate::operation::put_object::builders::PutObjectInputBuilder,
  106    102   
    config_override: ::std::option::Option<crate::config::Builder>,
  107    103   
}
  108    104   
impl crate::client::customize::internal::CustomizableSend<crate::operation::put_object::PutObjectOutput, crate::operation::put_object::PutObjectError>
  109    105   
    for PutObjectFluentBuilder
  110    106   
{
  111    107   
    fn send(
  112    108   
        self,
@@ -244,240 +317,299 @@
  264    260   
    /// <ul>
  265    261   
    /// <li>
  266    262   
    /// <p>This functionality is not supported for directory buckets.</p></li>
  267    263   
    /// <li>
  268    264   
    /// <p>This functionality is not supported for Amazon S3 on Outposts.</p></li>
  269    265   
    /// </ul>
  270    266   
    /// </note>
  271    267   
    pub fn get_acl(&self) -> &::std::option::Option<crate::types::ObjectCannedAcl> {
  272    268   
        self.inner.get_acl()
  273    269   
    }
  274         -
    /// <p>Object data.</p>
  275         -
    pub fn body(mut self, input: ::aws_smithy_types::byte_stream::ByteStream) -> Self {
  276         -
        self.inner = self.inner.body(input);
  277         -
        self
  278         -
    }
  279         -
    /// <p>Object data.</p>
  280         -
    pub fn set_body(mut self, input: ::std::option::Option<::aws_smithy_types::byte_stream::ByteStream>) -> Self {
  281         -
        self.inner = self.inner.set_body(input);
  282         -
        self
  283         -
    }
  284         -
    /// <p>Object data.</p>
  285         -
    pub fn get_body(&self) -> &::std::option::Option<::aws_smithy_types::byte_stream::ByteStream> {
  286         -
        self.inner.get_body()
  287         -
    }
  288    270   
    /// <p>The bucket name to which the PUT action was initiated.</p>
  289    271   
    /// <p><b>Directory buckets</b> - When you use this operation with a directory bucket, you must use virtual-hosted-style requests in the format <code> <i>Bucket-name</i>.s3express-<i>zone-id</i>.<i>region-code</i>.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Zone (Availability Zone or Local Zone). Bucket names must follow the format <code> <i>bucket-base-name</i>--<i>zone-id</i>--x-s3</code> (for example, <code> <i>amzn-s3-demo-bucket</i>--<i>usw2-az1</i>--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  290    272   
    /// <p><b>Access points</b> - When you use this action with an access point for general purpose buckets, you must provide the alias of the access point in place of the bucket name or specify the access point ARN. When you use this action with an access point for directory buckets, you must provide the access point name in place of the bucket name. When using the access point ARN, you must direct requests to the access point hostname. The access point hostname takes the form <i>AccessPointName</i>-<i>AccountId</i>.s3-accesspoint.<i>Region</i>.amazonaws.com. When using this action with an access point through the Amazon Web Services SDKs, you provide the access point ARN in place of the bucket name. For more information about access point ARNs, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-access-points.html">Using access points</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  291    273   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  292    274   
    /// </note>
  293    275   
    /// <p><b>S3 on Outposts</b> - When you use this action with S3 on Outposts, you must direct requests to the S3 on Outposts hostname. The S3 on Outposts hostname takes the form <code> <i>AccessPointName</i>-<i>AccountId</i>.<i>outpostID</i>.s3-outposts.<i>Region</i>.amazonaws.com</code>. When you use this action with S3 on Outposts, the destination bucket must be the Outposts access point ARN or the access point alias. For more information about S3 on Outposts, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/S3onOutposts.html">What is S3 on Outposts?</a> in the <i>Amazon S3 User Guide</i>.</p>
  294    276   
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  295    277   
        self.inner = self.inner.bucket(input.into());
  296    278   
        self
  297    279   
    }
@@ -788,770 +890,866 @@
  808    790   
    }
  809    791   
    /// <p>A map of metadata to store with the object in S3.</p>
  810    792   
    pub fn set_metadata(mut self, input: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>) -> Self {
  811    793   
        self.inner = self.inner.set_metadata(input);
  812    794   
        self
  813    795   
    }
  814    796   
    /// <p>A map of metadata to store with the object in S3.</p>
  815    797   
    pub fn get_metadata(&self) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>> {
  816    798   
        self.inner.get_metadata()
  817    799   
    }
  818         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
         800  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  819    801   
    /// <ul>
  820    802   
    /// <li>
  821    803   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
  822    804   
    /// <li>
  823    805   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
  824    806   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
  825    807   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
  826    808   
    /// </note></li>
  827         -
    /// <li>
  828         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
  829    809   
    /// </ul>
  830    810   
    pub fn server_side_encryption(mut self, input: crate::types::ServerSideEncryption) -> Self {
  831    811   
        self.inner = self.inner.server_side_encryption(input);
  832    812   
        self
  833    813   
    }
  834         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
         814  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  835    815   
    /// <ul>
  836    816   
    /// <li>
  837    817   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
  838    818   
    /// <li>
  839    819   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
  840    820   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
  841    821   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
  842    822   
    /// </note></li>
  843         -
    /// <li>
  844         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
  845    823   
    /// </ul>
  846    824   
    pub fn set_server_side_encryption(mut self, input: ::std::option::Option<crate::types::ServerSideEncryption>) -> Self {
  847    825   
        self.inner = self.inner.set_server_side_encryption(input);
  848    826   
        self
  849    827   
    }
  850         -
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 or Amazon FSx.</p>
         828  +
    /// <p>The server-side encryption algorithm that was used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  851    829   
    /// <ul>
  852    830   
    /// <li>
  853    831   
    /// <p><b>General purpose buckets </b> - You have four 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 or DSSE-KMS), and customer-provided keys (SSE-C). Amazon S3 encrypts data with server-side encryption by using Amazon S3 managed keys (SSE-S3) by default. You can optionally tell Amazon S3 to encrypt data at rest by using server-side encryption with other key options. 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>
  854    832   
    /// <li>
  855    833   
    /// <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>). We recommend that the bucket's default encryption uses the desired encryption configuration and you don't override the bucket default encryption in your <code>CreateSession</code> requests or <code>PUT</code> object requests. Then, new objects are automatically encrypted with the desired encryption settings. 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>. For more information about the encryption overriding behaviors in directory buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-specifying-kms-encryption.html">Specifying server-side encryption with KMS for new object uploads</a>.</p>
  856    834   
    /// <p>In the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>) using the REST API, the encryption request headers must match the encryption settings that are specified in the <code>CreateSession</code> request. You can't override the values of the encryption settings (<code>x-amz-server-side-encryption</code>, <code>x-amz-server-side-encryption-aws-kms-key-id</code>, <code>x-amz-server-side-encryption-context</code>, and <code>x-amz-server-side-encryption-bucket-key-enabled</code>) that are specified in the <code>CreateSession</code> request. You don't need to explicitly specify these encryption settings values in Zonal endpoint API calls, and Amazon S3 will use the encryption settings values from the <code>CreateSession</code> request to protect new objects in the directory bucket.</p><note>
  857    835   
    /// <p>When you use the CLI or the Amazon Web Services SDKs, for <code>CreateSession</code>, the session token refreshes automatically to avoid service interruptions when a session expires. The CLI or the Amazon Web Services SDKs use the bucket's default encryption configuration for the <code>CreateSession</code> request. It's not supported to override the encryption settings values in the <code>CreateSession</code> request. So in the Zonal endpoint API calls (except <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_UploadPartCopy.html">UploadPartCopy</a>), the encryption request headers must match the default encryption configuration of the directory bucket.</p>
  858    836   
    /// </note></li>
  859         -
    /// <li>
  860         -
    /// <p><b>S3 access points for Amazon FSx </b> - 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>. All Amazon FSx file systems have encryption configured by default and are encrypted at rest. Data is automatically encrypted before being written to the file system, and automatically decrypted as it is read. These processes are handled transparently by Amazon FSx.</p></li>
  861    837   
    /// </ul>
  862    838   
    pub fn get_server_side_encryption(&self) -> &::std::option::Option<crate::types::ServerSideEncryption> {
  863    839   
        self.inner.get_server_side_encryption()
  864    840   
    }
  865    841   
    /// <p>By default, Amazon S3 uses the STANDARD Storage Class to store newly created objects. The STANDARD storage class provides high durability and high availability. Depending on performance needs, you can specify a different Storage Class. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage Classes</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  866    842   
    /// <ul>
  867    843   
    /// <li>
  868    844   
    /// <p>Directory buckets only support <code>EXPRESS_ONEZONE</code> (the S3 Express One Zone storage class) in Availability Zones and <code>ONEZONE_IA</code> (the S3 One Zone-Infrequent Access storage class) in Dedicated Local Zones.</p></li>
  869    845   
    /// <li>
  870    846   
    /// <p>Amazon S3 on Outposts only uses the OUTPOSTS Storage Class.</p></li>

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

@@ -53,53 +113,113 @@
   73     73   
/// </ul>
   74     74   
/// <p>For example, the following <code>x-amz-grant-read</code> header grants list objects permission to the two Amazon Web Services accounts identified by their email addresses.</p>
   75     75   
/// <p><code>x-amz-grant-read: emailAddress="xyz@amazon.com", emailAddress="abc@amazon.com" </code></p></li>
   76     76   
/// </ul>
   77     77   
/// <p>You can use either a canned ACL or specify access permissions explicitly. You cannot do both.</p>
   78     78   
/// </dd>
   79     79   
/// <dt>
   80     80   
/// Grantee Values
   81     81   
/// </dt>
   82     82   
/// <dd>
   83         -
/// <p>You can specify the person (grantee) to whom you're assigning access rights (using request elements) in the following ways. For examples of how to specify these grantee values in JSON format, see the Amazon Web Services CLI example in <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/enable-server-access-logging.html"> Enabling Amazon S3 server access logging</a> in the <i>Amazon S3 User Guide</i>.</p>
          83  +
/// <p>You can specify the person (grantee) to whom you're assigning access rights (using request elements) in the following ways:</p>
   84     84   
/// <ul>
   85     85   
/// <li>
   86     86   
/// <p>By the person's ID:</p>
   87     87   
/// <p><code><grantee xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:type="CanonicalUser">
   88     88   
/// <id>
   89     89   
/// &lt;&gt;ID&lt;&gt;
   90     90   
/// </id>
   91     91   
/// <displayname>
   92     92   
/// &lt;&gt;GranteesEmail&lt;&gt;
   93     93   
/// </displayname>

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

@@ -1,0 +424,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
/// Orchestration and serialization glue logic for `RenameObject`.
    3         -
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4         -
#[non_exhaustive]
    5         -
pub struct RenameObject;
    6         -
impl RenameObject {
    7         -
    /// Creates a new `RenameObject`
    8         -
    pub fn new() -> Self {
    9         -
        Self
   10         -
    }
   11         -
    pub(crate) async fn orchestrate(
   12         -
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13         -
        input: crate::operation::rename_object::RenameObjectInput,
   14         -
    ) -> ::std::result::Result<
   15         -
        crate::operation::rename_object::RenameObjectOutput,
   16         -
        ::aws_smithy_runtime_api::client::result::SdkError<
   17         -
            crate::operation::rename_object::RenameObjectError,
   18         -
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19         -
        >,
   20         -
    > {
   21         -
        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
   22         -
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
   23         -
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   24         -
        >| {
   25         -
            err.map_service_error(|err| {
   26         -
                err.downcast::<crate::operation::rename_object::RenameObjectError>()
   27         -
                    .expect("correct error type")
   28         -
            })
   29         -
        };
   30         -
        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
   31         -
            .await
   32         -
            .map_err(map_err)?;
   33         -
        let output = context.finalize().map_err(map_err)?;
   34         -
        ::std::result::Result::Ok(
   35         -
            output
   36         -
                .downcast::<crate::operation::rename_object::RenameObjectOutput>()
   37         -
                .expect("correct output type"),
   38         -
        )
   39         -
    }
   40         -
   41         -
    pub(crate) async fn orchestrate_with_stop_point(
   42         -
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   43         -
        input: crate::operation::rename_object::RenameObjectInput,
   44         -
        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
   45         -
    ) -> ::std::result::Result<
   46         -
        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
   47         -
        ::aws_smithy_runtime_api::client::result::SdkError<
   48         -
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
   49         -
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   50         -
        >,
   51         -
    > {
   52         -
        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
   53         -
        use ::tracing::Instrument;
   54         -
        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("S3", "RenameObject", input, runtime_plugins, stop_point)
   55         -
            // Create a parent span for the entire operation. Includes a random, internal-only,
   56         -
            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
   57         -
            .instrument(::tracing::debug_span!(
   58         -
                "S3.RenameObject",
   59         -
                "rpc.service" = "S3",
   60         -
                "rpc.method" = "RenameObject",
   61         -
                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
   62         -
                "rpc.system" = "aws-api",
   63         -
            ))
   64         -
            .await
   65         -
    }
   66         -
   67         -
    pub(crate) fn operation_runtime_plugins(
   68         -
        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   69         -
        client_config: &crate::config::Config,
   70         -
        config_override: ::std::option::Option<crate::config::Builder>,
   71         -
    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
   72         -
        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
   73         -
        runtime_plugins = runtime_plugins.with_operation_plugin(crate::client_idempotency_token::IdempotencyTokenRuntimePlugin::new(
   74         -
            |token_provider, input| {
   75         -
                let input: &mut crate::operation::rename_object::RenameObjectInput = input.downcast_mut().expect("correct type");
   76         -
                if input.client_token.is_none() {
   77         -
                    input.client_token = ::std::option::Option::Some(token_provider.make_idempotency_token());
   78         -
                }
   79         -
            },
   80         -
        ));
   81         -
        if let ::std::option::Option::Some(config_override) = config_override {
   82         -
            for plugin in config_override.runtime_plugins.iter().cloned() {
   83         -
                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
   84         -
            }
   85         -
            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
   86         -
                config_override,
   87         -
                client_config.config.clone(),
   88         -
                &client_config.runtime_components,
   89         -
            ));
   90         -
        }
   91         -
        runtime_plugins
   92         -
    }
   93         -
}
   94         -
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for RenameObject {
   95         -
    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
   96         -
        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RenameObject");
   97         -
   98         -
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
   99         -
            RenameObjectRequestSerializer,
  100         -
        ));
  101         -
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
  102         -
            RenameObjectResponseDeserializer,
  103         -
        ));
  104         -
  105         -
        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
  106         -
            crate::config::auth::Params::builder()
  107         -
                .operation_name("RenameObject")
  108         -
                .build()
  109         -
                .expect("required fields set"),
  110         -
        ));
  111         -
  112         -
        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("RenameObject", "S3"));
  113         -
        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
  114         -
        signing_options.double_uri_encode = false;
  115         -
        signing_options.content_sha256_header = true;
  116         -
        signing_options.normalize_uri_path = false;
  117         -
        signing_options.payload_override = None;
  118         -
  119         -
        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
  120         -
            signing_options,
  121         -
            ..::std::default::Default::default()
  122         -
        });
  123         -
  124         -
        ::std::option::Option::Some(cfg.freeze())
  125         -
    }
  126         -
  127         -
    fn runtime_components(
  128         -
        &self,
  129         -
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  130         -
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  131         -
        #[allow(unused_mut)]
  132         -
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("RenameObject")
  133         -
            .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
  134         -
            .with_interceptor(RenameObjectEndpointParamsInterceptor)
  135         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
  136         -
                crate::operation::rename_object::RenameObjectError,
  137         -
            >::new())
  138         -
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
  139         -
                crate::operation::rename_object::RenameObjectError,
  140         -
            >::new())
  141         -
            .with_retry_classifier(
  142         -
                ::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<crate::operation::rename_object::RenameObjectError>::builder()
  143         -
                    .transient_errors({
  144         -
                        let mut transient_errors: Vec<&'static str> = ::aws_runtime::retries::classifiers::TRANSIENT_ERRORS.into();
  145         -
                        transient_errors.push("InternalError");
  146         -
                        ::std::borrow::Cow::Owned(transient_errors)
  147         -
                    })
  148         -
                    .build(),
  149         -
            );
  150         -
  151         -
        ::std::borrow::Cow::Owned(rcb)
  152         -
    }
  153         -
}
  154         -
  155         -
#[derive(Debug)]
  156         -
struct RenameObjectResponseDeserializer;
  157         -
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RenameObjectResponseDeserializer {
  158         -
    fn deserialize_nonstreaming(
  159         -
        &self,
  160         -
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
  161         -
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  162         -
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  163         -
        let headers = response.headers();
  164         -
        let body = response.body().bytes().expect("body loaded");
  165         -
        #[allow(unused_mut)]
  166         -
        let mut force_error = false;
  167         -
        ::tracing::debug!(extended_request_id = ?crate::s3_request_id::RequestIdExt::extended_request_id(response));
  168         -
        if matches!(crate::rest_xml_unwrapped_errors::body_is_error(body), Ok(true)) {
  169         -
            force_error = true;
  170         -
        }
  171         -
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  172         -
        let parse_result = if !success && status != 200 || force_error {
  173         -
            crate::protocol_serde::shape_rename_object::de_rename_object_http_error(status, headers, body)
  174         -
        } else {
  175         -
            crate::protocol_serde::shape_rename_object::de_rename_object_http_response(status, headers, body)
  176         -
        };
  177         -
        crate::protocol_serde::type_erase_result(parse_result)
  178         -
    }
  179         -
}
  180         -
#[derive(Debug)]
  181         -
struct RenameObjectRequestSerializer;
  182         -
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RenameObjectRequestSerializer {
  183         -
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  184         -
    fn serialize_input(
  185         -
        &self,
  186         -
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  187         -
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  188         -
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  189         -
        let input = input
  190         -
            .downcast::<crate::operation::rename_object::RenameObjectInput>()
  191         -
            .expect("correct type");
  192         -
        let _header_serialization_settings = _cfg
  193         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  194         -
            .cloned()
  195         -
            .unwrap_or_default();
  196         -
        let mut request_builder = {
  197         -
            #[allow(clippy::uninlined_format_args)]
  198         -
            fn uri_base(
  199         -
                _input: &crate::operation::rename_object::RenameObjectInput,
  200         -
                output: &mut ::std::string::String,
  201         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  202         -
                use ::std::fmt::Write as _;
  203         -
                let input_1 = &_input.key;
  204         -
                let input_1 = input_1
  205         -
                    .as_ref()
  206         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "cannot be empty or unset"))?;
  207         -
                let key = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Greedy);
  208         -
                if key.is_empty() {
  209         -
                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
  210         -
                        "key",
  211         -
                        "cannot be empty or unset",
  212         -
                    ));
  213         -
                }
  214         -
                ::std::write!(output, "/{Key}", Key = key).expect("formatting should succeed");
  215         -
                ::std::result::Result::Ok(())
  216         -
            }
  217         -
            fn uri_query(
  218         -
                _input: &crate::operation::rename_object::RenameObjectInput,
  219         -
                mut output: &mut ::std::string::String,
  220         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  221         -
                let mut query = ::aws_smithy_http::query::Writer::new(output);
  222         -
                query.push_v("renameObject");
  223         -
                ::std::result::Result::Ok(())
  224         -
            }
  225         -
            #[allow(clippy::unnecessary_wraps)]
  226         -
            fn update_http_builder(
  227         -
                input: &crate::operation::rename_object::RenameObjectInput,
  228         -
                builder: ::http::request::Builder,
  229         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  230         -
                let mut uri = ::std::string::String::new();
  231         -
                uri_base(input, &mut uri)?;
  232         -
                uri_query(input, &mut uri)?;
  233         -
                let builder = crate::protocol_serde::shape_rename_object::ser_rename_object_headers(input, builder)?;
  234         -
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  235         -
            }
  236         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  237         -
            builder
  238         -
        };
  239         -
        let body = ::aws_smithy_types::body::SdkBody::from("");
  240         -
  241         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  242         -
    }
  243         -
}
  244         -
#[derive(Debug)]
  245         -
struct RenameObjectEndpointParamsInterceptor;
  246         -
  247         -
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RenameObjectEndpointParamsInterceptor {
  248         -
    fn name(&self) -> &'static str {
  249         -
        "RenameObjectEndpointParamsInterceptor"
  250         -
    }
  251         -
  252         -
    fn read_before_execution(
  253         -
        &self,
  254         -
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
  255         -
            '_,
  256         -
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
  257         -
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
  258         -
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
  259         -
        >,
  260         -
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  261         -
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
  262         -
        let _input = context
  263         -
            .input()
  264         -
            .downcast_ref::<RenameObjectInput>()
  265         -
            .ok_or("failed to downcast to RenameObjectInput")?;
  266         -
  267         -
        let params = crate::config::endpoint::Params::builder()
  268         -
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
  269         -
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
  270         -
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
  271         -
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
  272         -
            .set_force_path_style(cfg.load::<crate::config::ForcePathStyle>().map(|ty| ty.0))
  273         -
            .set_use_arn_region(cfg.load::<crate::config::UseArnRegion>().map(|ty| ty.0))
  274         -
            .set_disable_multi_region_access_points(cfg.load::<crate::config::DisableMultiRegionAccessPoints>().map(|ty| ty.0))
  275         -
            .set_accelerate(cfg.load::<crate::config::Accelerate>().map(|ty| ty.0))
  276         -
            .set_disable_s3_express_session_auth(cfg.load::<crate::config::DisableS3ExpressSessionAuth>().map(|ty| ty.0))
  277         -
            .set_bucket(Some(
  278         -
                _input
  279         -
                    .bucket
  280         -
                    .clone()
  281         -
                    .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
  282         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("bucket", "A required field was not set"))?,
  283         -
            ))
  284         -
            .set_key(Some(
  285         -
                _input
  286         -
                    .key
  287         -
                    .clone()
  288         -
                    .filter(|f| !AsRef::<str>::as_ref(f).trim().is_empty())
  289         -
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("key", "A required field was not set"))?,
  290         -
            ))
  291         -
            .build()
  292         -
            .map_err(|err| {
  293         -
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
  294         -
            })?;
  295         -
        cfg.interceptor_state()
  296         -
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
  297         -
        ::std::result::Result::Ok(())
  298         -
    }
  299         -
}
  300         -
  301         -
// The get_* functions below are generated from JMESPath expressions in the
  302         -
// operationContextParams trait. They target the operation's input shape.
  303         -
  304         -
/// Error type for the `RenameObjectError` operation.
  305         -
#[non_exhaustive]
  306         -
#[derive(::std::fmt::Debug)]
  307         -
pub enum RenameObjectError {
  308         -
    /// <p>Parameters on this idempotent request are inconsistent with parameters used in previous request(s).</p>
  309         -
    /// <p>For a list of error codes and more information on Amazon S3 errors, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/ErrorResponses.html#ErrorCodeList">Error codes</a>.</p><note>
  310         -
    /// <p>Idempotency ensures that an API request completes no more than one time. With an idempotent request, if the original request completes successfully, any subsequent retries complete successfully without performing any further actions.</p>
  311         -
    /// </note>
  312         -
    IdempotencyParameterMismatch(crate::types::error::IdempotencyParameterMismatch),
  313         -
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
  314         -
    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
  315         -
    variable wildcard pattern and check `.code()`:
  316         -
     \
  317         -
    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
  318         -
     \
  319         -
    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-RenameObjectError) for what information is available for the error.")]
  320         -
    Unhandled(crate::error::sealed_unhandled::Unhandled),
  321         -
}
  322         -
impl RenameObjectError {
  323         -
    /// Creates the `RenameObjectError::Unhandled` variant from any error type.
  324         -
    pub fn unhandled(
  325         -
        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
  326         -
    ) -> Self {
  327         -
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
  328         -
            source: err.into(),
  329         -
            meta: ::std::default::Default::default(),
  330         -
        })
  331         -
    }
  332         -
  333         -
    /// Creates the `RenameObjectError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
  334         -
    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
  335         -
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
  336         -
            source: err.clone().into(),
  337         -
            meta: err,
  338         -
        })
  339         -
    }
  340         -
    ///
  341         -
    /// Returns error metadata, which includes the error code, message,
  342         -
    /// request ID, and potentially additional information.
  343         -
    ///
  344         -
    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
  345         -
        match self {
  346         -
            Self::IdempotencyParameterMismatch(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
  347         -
            Self::Unhandled(e) => &e.meta,
  348         -
        }
  349         -
    }
  350         -
    /// Returns `true` if the error kind is `RenameObjectError::IdempotencyParameterMismatch`.
  351         -
    pub fn is_idempotency_parameter_mismatch(&self) -> bool {
  352         -
        matches!(self, Self::IdempotencyParameterMismatch(_))
  353         -
    }
  354         -
}
  355         -
impl ::std::error::Error for RenameObjectError {
  356         -
    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
  357         -
        match self {
  358         -
            Self::IdempotencyParameterMismatch(_inner) => ::std::option::Option::Some(_inner),
  359         -
            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
  360         -
        }
  361         -
    }
  362         -
}
  363         -
impl ::std::fmt::Display for RenameObjectError {
  364         -
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
  365         -
        match self {
  366         -
            Self::IdempotencyParameterMismatch(_inner) => _inner.fmt(f),
  367         -
            Self::Unhandled(_inner) => {
  368         -
                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
  369         -
                    write!(f, "unhandled error ({code})")
  370         -
                } else {
  371         -
                    f.write_str("unhandled error")
  372         -
                }
  373         -
            }
  374         -
        }
  375         -
    }
  376         -
}
  377         -
impl ::aws_smithy_types::retry::ProvideErrorKind for RenameObjectError {
  378         -
    fn code(&self) -> ::std::option::Option<&str> {
  379         -
        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
  380         -
    }
  381         -
    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
  382         -
        ::std::option::Option::None
  383         -
    }
  384         -
}
  385         -
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for RenameObjectError {
  386         -
    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
  387         -
        match self {
  388         -
            Self::IdempotencyParameterMismatch(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
  389         -
            Self::Unhandled(_inner) => &_inner.meta,
  390         -
        }
  391         -
    }
  392         -
}
  393         -
impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for RenameObjectError {
  394         -
    fn create_unhandled_error(
  395         -
        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
  396         -
        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
  397         -
    ) -> Self {
  398         -
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
  399         -
            source,
  400         -
            meta: meta.unwrap_or_default(),
  401         -
        })
  402         -
    }
  403         -
}
  404         -
impl crate::s3_request_id::RequestIdExt for crate::operation::rename_object::RenameObjectError {
  405         -
    fn extended_request_id(&self) -> Option<&str> {
  406         -
        self.meta().extended_request_id()
  407         -
    }
  408         -
}
  409         -
impl ::aws_types::request_id::RequestId for crate::operation::rename_object::RenameObjectError {
  410         -
    fn request_id(&self) -> Option<&str> {
  411         -
        self.meta().request_id()
  412         -
    }
  413         -
}
  414         -
  415         -
pub use crate::operation::rename_object::_rename_object_output::RenameObjectOutput;
  416         -
  417         -
pub use crate::operation::rename_object::_rename_object_input::RenameObjectInput;
  418         -
  419         -
mod _rename_object_input;
  420         -
  421         -
mod _rename_object_output;
  422         -
  423         -
/// Builders
  424         -
pub mod builders;

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/rename_object/_rename_object_input.rs

@@ -1,0 +321,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(missing_docs)] // documentation missing in model
    3         -
#[non_exhaustive]
    4         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5         -
pub struct RenameObjectInput {
    6         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
    7         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
    8         -
    pub bucket: ::std::option::Option<::std::string::String>,
    9         -
    /// <p>Key name of the object to rename.</p>
   10         -
    pub key: ::std::option::Option<::std::string::String>,
   11         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
   12         -
    pub rename_source: ::std::option::Option<::std::string::String>,
   13         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
   14         -
    /// <p>Expects the ETag value as a string.</p>
   15         -
    pub destination_if_match: ::std::option::Option<::std::string::String>,
   16         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
   17         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
   18         -
    pub destination_if_none_match: ::std::option::Option<::std::string::String>,
   19         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
   20         -
    pub destination_if_modified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
   21         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
   22         -
    pub destination_if_unmodified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
   23         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
   24         -
    pub source_if_match: ::std::option::Option<::std::string::String>,
   25         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
   26         -
    pub source_if_none_match: ::std::option::Option<::std::string::String>,
   27         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
   28         -
    pub source_if_modified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
   29         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
   30         -
    pub source_if_unmodified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
   31         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
   32         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
   33         -
    /// </note>
   34         -
    pub client_token: ::std::option::Option<::std::string::String>,
   35         -
}
   36         -
impl RenameObjectInput {
   37         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
   38         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
   39         -
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   40         -
        self.bucket.as_deref()
   41         -
    }
   42         -
    /// <p>Key name of the object to rename.</p>
   43         -
    pub fn key(&self) -> ::std::option::Option<&str> {
   44         -
        self.key.as_deref()
   45         -
    }
   46         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
   47         -
    pub fn rename_source(&self) -> ::std::option::Option<&str> {
   48         -
        self.rename_source.as_deref()
   49         -
    }
   50         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
   51         -
    /// <p>Expects the ETag value as a string.</p>
   52         -
    pub fn destination_if_match(&self) -> ::std::option::Option<&str> {
   53         -
        self.destination_if_match.as_deref()
   54         -
    }
   55         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
   56         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
   57         -
    pub fn destination_if_none_match(&self) -> ::std::option::Option<&str> {
   58         -
        self.destination_if_none_match.as_deref()
   59         -
    }
   60         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
   61         -
    pub fn destination_if_modified_since(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   62         -
        self.destination_if_modified_since.as_ref()
   63         -
    }
   64         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
   65         -
    pub fn destination_if_unmodified_since(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   66         -
        self.destination_if_unmodified_since.as_ref()
   67         -
    }
   68         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
   69         -
    pub fn source_if_match(&self) -> ::std::option::Option<&str> {
   70         -
        self.source_if_match.as_deref()
   71         -
    }
   72         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
   73         -
    pub fn source_if_none_match(&self) -> ::std::option::Option<&str> {
   74         -
        self.source_if_none_match.as_deref()
   75         -
    }
   76         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
   77         -
    pub fn source_if_modified_since(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   78         -
        self.source_if_modified_since.as_ref()
   79         -
    }
   80         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
   81         -
    pub fn source_if_unmodified_since(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   82         -
        self.source_if_unmodified_since.as_ref()
   83         -
    }
   84         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
   85         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
   86         -
    /// </note>
   87         -
    pub fn client_token(&self) -> ::std::option::Option<&str> {
   88         -
        self.client_token.as_deref()
   89         -
    }
   90         -
}
   91         -
impl RenameObjectInput {
   92         -
    /// Creates a new builder-style object to manufacture [`RenameObjectInput`](crate::operation::rename_object::RenameObjectInput).
   93         -
    pub fn builder() -> crate::operation::rename_object::builders::RenameObjectInputBuilder {
   94         -
        crate::operation::rename_object::builders::RenameObjectInputBuilder::default()
   95         -
    }
   96         -
}
   97         -
   98         -
/// A builder for [`RenameObjectInput`](crate::operation::rename_object::RenameObjectInput).
   99         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  100         -
#[non_exhaustive]
  101         -
pub struct RenameObjectInputBuilder {
  102         -
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
  103         -
    pub(crate) key: ::std::option::Option<::std::string::String>,
  104         -
    pub(crate) rename_source: ::std::option::Option<::std::string::String>,
  105         -
    pub(crate) destination_if_match: ::std::option::Option<::std::string::String>,
  106         -
    pub(crate) destination_if_none_match: ::std::option::Option<::std::string::String>,
  107         -
    pub(crate) destination_if_modified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
  108         -
    pub(crate) destination_if_unmodified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
  109         -
    pub(crate) source_if_match: ::std::option::Option<::std::string::String>,
  110         -
    pub(crate) source_if_none_match: ::std::option::Option<::std::string::String>,
  111         -
    pub(crate) source_if_modified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
  112         -
    pub(crate) source_if_unmodified_since: ::std::option::Option<::aws_smithy_types::DateTime>,
  113         -
    pub(crate) client_token: ::std::option::Option<::std::string::String>,
  114         -
}
  115         -
impl RenameObjectInputBuilder {
  116         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  117         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  118         -
    /// This field is required.
  119         -
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  120         -
        self.bucket = ::std::option::Option::Some(input.into());
  121         -
        self
  122         -
    }
  123         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  124         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  125         -
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  126         -
        self.bucket = input;
  127         -
        self
  128         -
    }
  129         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  130         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  131         -
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  132         -
        &self.bucket
  133         -
    }
  134         -
    /// <p>Key name of the object to rename.</p>
  135         -
    /// This field is required.
  136         -
    pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  137         -
        self.key = ::std::option::Option::Some(input.into());
  138         -
        self
  139         -
    }
  140         -
    /// <p>Key name of the object to rename.</p>
  141         -
    pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  142         -
        self.key = input;
  143         -
        self
  144         -
    }
  145         -
    /// <p>Key name of the object to rename.</p>
  146         -
    pub fn get_key(&self) -> &::std::option::Option<::std::string::String> {
  147         -
        &self.key
  148         -
    }
  149         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  150         -
    /// This field is required.
  151         -
    pub fn rename_source(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  152         -
        self.rename_source = ::std::option::Option::Some(input.into());
  153         -
        self
  154         -
    }
  155         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  156         -
    pub fn set_rename_source(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  157         -
        self.rename_source = input;
  158         -
        self
  159         -
    }
  160         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  161         -
    pub fn get_rename_source(&self) -> &::std::option::Option<::std::string::String> {
  162         -
        &self.rename_source
  163         -
    }
  164         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  165         -
    /// <p>Expects the ETag value as a string.</p>
  166         -
    pub fn destination_if_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  167         -
        self.destination_if_match = ::std::option::Option::Some(input.into());
  168         -
        self
  169         -
    }
  170         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  171         -
    /// <p>Expects the ETag value as a string.</p>
  172         -
    pub fn set_destination_if_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  173         -
        self.destination_if_match = input;
  174         -
        self
  175         -
    }
  176         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  177         -
    /// <p>Expects the ETag value as a string.</p>
  178         -
    pub fn get_destination_if_match(&self) -> &::std::option::Option<::std::string::String> {
  179         -
        &self.destination_if_match
  180         -
    }
  181         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  182         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  183         -
    pub fn destination_if_none_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  184         -
        self.destination_if_none_match = ::std::option::Option::Some(input.into());
  185         -
        self
  186         -
    }
  187         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  188         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  189         -
    pub fn set_destination_if_none_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  190         -
        self.destination_if_none_match = input;
  191         -
        self
  192         -
    }
  193         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  194         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  195         -
    pub fn get_destination_if_none_match(&self) -> &::std::option::Option<::std::string::String> {
  196         -
        &self.destination_if_none_match
  197         -
    }
  198         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  199         -
    pub fn destination_if_modified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  200         -
        self.destination_if_modified_since = ::std::option::Option::Some(input);
  201         -
        self
  202         -
    }
  203         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  204         -
    pub fn set_destination_if_modified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  205         -
        self.destination_if_modified_since = input;
  206         -
        self
  207         -
    }
  208         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  209         -
    pub fn get_destination_if_modified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  210         -
        &self.destination_if_modified_since
  211         -
    }
  212         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  213         -
    pub fn destination_if_unmodified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  214         -
        self.destination_if_unmodified_since = ::std::option::Option::Some(input);
  215         -
        self
  216         -
    }
  217         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  218         -
    pub fn set_destination_if_unmodified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  219         -
        self.destination_if_unmodified_since = input;
  220         -
        self
  221         -
    }
  222         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  223         -
    pub fn get_destination_if_unmodified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  224         -
        &self.destination_if_unmodified_since
  225         -
    }
  226         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  227         -
    pub fn source_if_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  228         -
        self.source_if_match = ::std::option::Option::Some(input.into());
  229         -
        self
  230         -
    }
  231         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  232         -
    pub fn set_source_if_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  233         -
        self.source_if_match = input;
  234         -
        self
  235         -
    }
  236         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  237         -
    pub fn get_source_if_match(&self) -> &::std::option::Option<::std::string::String> {
  238         -
        &self.source_if_match
  239         -
    }
  240         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  241         -
    pub fn source_if_none_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  242         -
        self.source_if_none_match = ::std::option::Option::Some(input.into());
  243         -
        self
  244         -
    }
  245         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  246         -
    pub fn set_source_if_none_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  247         -
        self.source_if_none_match = input;
  248         -
        self
  249         -
    }
  250         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  251         -
    pub fn get_source_if_none_match(&self) -> &::std::option::Option<::std::string::String> {
  252         -
        &self.source_if_none_match
  253         -
    }
  254         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  255         -
    pub fn source_if_modified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  256         -
        self.source_if_modified_since = ::std::option::Option::Some(input);
  257         -
        self
  258         -
    }
  259         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  260         -
    pub fn set_source_if_modified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  261         -
        self.source_if_modified_since = input;
  262         -
        self
  263         -
    }
  264         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  265         -
    pub fn get_source_if_modified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  266         -
        &self.source_if_modified_since
  267         -
    }
  268         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  269         -
    pub fn source_if_unmodified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  270         -
        self.source_if_unmodified_since = ::std::option::Option::Some(input);
  271         -
        self
  272         -
    }
  273         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  274         -
    pub fn set_source_if_unmodified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  275         -
        self.source_if_unmodified_since = input;
  276         -
        self
  277         -
    }
  278         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  279         -
    pub fn get_source_if_unmodified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  280         -
        &self.source_if_unmodified_since
  281         -
    }
  282         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  283         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  284         -
    /// </note>
  285         -
    pub fn client_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  286         -
        self.client_token = ::std::option::Option::Some(input.into());
  287         -
        self
  288         -
    }
  289         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  290         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  291         -
    /// </note>
  292         -
    pub fn set_client_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  293         -
        self.client_token = input;
  294         -
        self
  295         -
    }
  296         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  297         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  298         -
    /// </note>
  299         -
    pub fn get_client_token(&self) -> &::std::option::Option<::std::string::String> {
  300         -
        &self.client_token
  301         -
    }
  302         -
    /// Consumes the builder and constructs a [`RenameObjectInput`](crate::operation::rename_object::RenameObjectInput).
  303         -
    pub fn build(
  304         -
        self,
  305         -
    ) -> ::std::result::Result<crate::operation::rename_object::RenameObjectInput, ::aws_smithy_types::error::operation::BuildError> {
  306         -
        ::std::result::Result::Ok(crate::operation::rename_object::RenameObjectInput {
  307         -
            bucket: self.bucket,
  308         -
            key: self.key,
  309         -
            rename_source: self.rename_source,
  310         -
            destination_if_match: self.destination_if_match,
  311         -
            destination_if_none_match: self.destination_if_none_match,
  312         -
            destination_if_modified_since: self.destination_if_modified_since,
  313         -
            destination_if_unmodified_since: self.destination_if_unmodified_since,
  314         -
            source_if_match: self.source_if_match,
  315         -
            source_if_none_match: self.source_if_none_match,
  316         -
            source_if_modified_since: self.source_if_modified_since,
  317         -
            source_if_unmodified_since: self.source_if_unmodified_since,
  318         -
            client_token: self.client_token,
  319         -
        })
  320         -
    }
  321         -
}

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/rename_object/_rename_object_output.rs

@@ -1,0 +59,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
#[allow(missing_docs)] // documentation missing in model
    3         -
#[non_exhaustive]
    4         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5         -
pub struct RenameObjectOutput {
    6         -
    _extended_request_id: Option<String>,
    7         -
    _request_id: Option<String>,
    8         -
}
    9         -
impl crate::s3_request_id::RequestIdExt for RenameObjectOutput {
   10         -
    fn extended_request_id(&self) -> Option<&str> {
   11         -
        self._extended_request_id.as_deref()
   12         -
    }
   13         -
}
   14         -
impl ::aws_types::request_id::RequestId for RenameObjectOutput {
   15         -
    fn request_id(&self) -> Option<&str> {
   16         -
        self._request_id.as_deref()
   17         -
    }
   18         -
}
   19         -
impl RenameObjectOutput {
   20         -
    /// Creates a new builder-style object to manufacture [`RenameObjectOutput`](crate::operation::rename_object::RenameObjectOutput).
   21         -
    pub fn builder() -> crate::operation::rename_object::builders::RenameObjectOutputBuilder {
   22         -
        crate::operation::rename_object::builders::RenameObjectOutputBuilder::default()
   23         -
    }
   24         -
}
   25         -
   26         -
/// A builder for [`RenameObjectOutput`](crate::operation::rename_object::RenameObjectOutput).
   27         -
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   28         -
#[non_exhaustive]
   29         -
pub struct RenameObjectOutputBuilder {
   30         -
    _extended_request_id: Option<String>,
   31         -
    _request_id: Option<String>,
   32         -
}
   33         -
impl RenameObjectOutputBuilder {
   34         -
    pub(crate) fn _extended_request_id(mut self, extended_request_id: impl Into<String>) -> Self {
   35         -
        self._extended_request_id = Some(extended_request_id.into());
   36         -
        self
   37         -
    }
   38         -
   39         -
    pub(crate) fn _set_extended_request_id(&mut self, extended_request_id: Option<String>) -> &mut Self {
   40         -
        self._extended_request_id = extended_request_id;
   41         -
        self
   42         -
    }
   43         -
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
   44         -
        self._request_id = Some(request_id.into());
   45         -
        self
   46         -
    }
   47         -
   48         -
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
   49         -
        self._request_id = request_id;
   50         -
        self
   51         -
    }
   52         -
    /// Consumes the builder and constructs a [`RenameObjectOutput`](crate::operation::rename_object::RenameObjectOutput).
   53         -
    pub fn build(self) -> crate::operation::rename_object::RenameObjectOutput {
   54         -
        crate::operation::rename_object::RenameObjectOutput {
   55         -
            _extended_request_id: self._extended_request_id,
   56         -
            _request_id: self._request_id,
   57         -
        }
   58         -
    }
   59         -
}

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

@@ -1,0 +315,0 @@
    1         -
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
pub use crate::operation::rename_object::_rename_object_output::RenameObjectOutputBuilder;
    3         -
    4         -
pub use crate::operation::rename_object::_rename_object_input::RenameObjectInputBuilder;
    5         -
    6         -
impl crate::operation::rename_object::builders::RenameObjectInputBuilder {
    7         -
    /// Sends a request with this input using the given client.
    8         -
    pub async fn send_with(
    9         -
        self,
   10         -
        client: &crate::Client,
   11         -
    ) -> ::std::result::Result<
   12         -
        crate::operation::rename_object::RenameObjectOutput,
   13         -
        ::aws_smithy_runtime_api::client::result::SdkError<
   14         -
            crate::operation::rename_object::RenameObjectError,
   15         -
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   16         -
        >,
   17         -
    > {
   18         -
        let mut fluent_builder = client.rename_object();
   19         -
        fluent_builder.inner = self;
   20         -
        fluent_builder.send().await
   21         -
    }
   22         -
}
   23         -
/// Fluent builder constructing a request to `RenameObject`.
   24         -
///
   25         -
/// <p>Renames an existing object in a directory bucket that uses the S3 Express One Zone storage class. You can use <code>RenameObject</code> by specifying an existing object’s name as the source and the new name of the object as the destination within the same directory bucket.</p><note>
   26         -
/// <p><code>RenameObject</code> is only supported for objects stored in the S3 Express One Zone storage class.</p>
   27         -
/// </note>
   28         -
/// <p>To prevent overwriting an object, you can use the <code>If-None-Match</code> conditional header.</p>
   29         -
/// <ul>
   30         -
/// <li>
   31         -
/// <p><b>If-None-Match</b> - Renames the object only if an object with the specified name does not already exist in the directory bucket. If you don't want to overwrite an existing object, you can add the <code>If-None-Match</code> conditional header with the value <code>‘*’</code> in the <code>RenameObject</code> request. Amazon S3 then returns a <code>412 Precondition Failed</code> error if the object with the specified name already exists. For more information, see <a href="https://datatracker.ietf.org/doc/rfc7232/">RFC 7232</a>.</p></li>
   32         -
/// </ul>
   33         -
/// <dl>
   34         -
/// <dt>
   35         -
/// Permissions
   36         -
/// </dt>
   37         -
/// <dd>
   38         -
/// <p>To grant access to the <code>RenameObject</code> operation on a directory bucket, we recommend that you use the <code>CreateSession</code> operation for session-based authorization. Specifically, you grant the <code>s3express:CreateSession</code> permission to the directory bucket in a bucket policy or an IAM identity-based policy. Then, you make the <code>CreateSession</code> API call on the directory bucket to obtain a session token. With the session token in your request header, you can make API requests to this operation. After the session token expires, you make another <code>CreateSession</code> API call to generate a new session token for use. The Amazon Web Services CLI and SDKs will create and manage your session including refreshing the session token automatically to avoid service interruptions when a session expires. In your bucket policy, you can specify the <code>s3express:SessionMode</code> condition key to control who can create a <code>ReadWrite</code> or <code>ReadOnly</code> session. A <code>ReadWrite</code> session is required for executing all the Zonal endpoint API operations, including <code>RenameObject</code>. For more information about authorization, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html"> <code>CreateSession</code> </a>. To learn more about Zonal endpoint API operations, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-create-session.html">Authorizing Zonal endpoint API operations with CreateSession</a> in the <i>Amazon S3 User Guide</i>.</p>
   39         -
/// </dd>
   40         -
/// <dt>
   41         -
/// HTTP Host header syntax
   42         -
/// </dt>
   43         -
/// <dd>
   44         -
/// <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>
   45         -
/// </dd>
   46         -
/// </dl>
   47         -
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
   48         -
pub struct RenameObjectFluentBuilder {
   49         -
    handle: ::std::sync::Arc<crate::client::Handle>,
   50         -
    inner: crate::operation::rename_object::builders::RenameObjectInputBuilder,
   51         -
    config_override: ::std::option::Option<crate::config::Builder>,
   52         -
}
   53         -
impl
   54         -
    crate::client::customize::internal::CustomizableSend<
   55         -
        crate::operation::rename_object::RenameObjectOutput,
   56         -
        crate::operation::rename_object::RenameObjectError,
   57         -
    > for RenameObjectFluentBuilder
   58         -
{
   59         -
    fn send(
   60         -
        self,
   61         -
        config_override: crate::config::Builder,
   62         -
    ) -> crate::client::customize::internal::BoxFuture<
   63         -
        crate::client::customize::internal::SendResult<
   64         -
            crate::operation::rename_object::RenameObjectOutput,
   65         -
            crate::operation::rename_object::RenameObjectError,
   66         -
        >,
   67         -
    > {
   68         -
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
   69         -
    }
   70         -
}
   71         -
impl RenameObjectFluentBuilder {
   72         -
    /// Creates a new `RenameObjectFluentBuilder`.
   73         -
    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
   74         -
        Self {
   75         -
            handle,
   76         -
            inner: ::std::default::Default::default(),
   77         -
            config_override: ::std::option::Option::None,
   78         -
        }
   79         -
    }
   80         -
    /// Access the RenameObject as a reference.
   81         -
    pub fn as_input(&self) -> &crate::operation::rename_object::builders::RenameObjectInputBuilder {
   82         -
        &self.inner
   83         -
    }
   84         -
    /// Sends the request and returns the response.
   85         -
    ///
   86         -
    /// If an error occurs, an `SdkError` will be returned with additional details that
   87         -
    /// can be matched against.
   88         -
    ///
   89         -
    /// By default, any retryable failures will be retried twice. Retry behavior
   90         -
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
   91         -
    /// set when configuring the client.
   92         -
    pub async fn send(
   93         -
        self,
   94         -
    ) -> ::std::result::Result<
   95         -
        crate::operation::rename_object::RenameObjectOutput,
   96         -
        ::aws_smithy_runtime_api::client::result::SdkError<
   97         -
            crate::operation::rename_object::RenameObjectError,
   98         -
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   99         -
        >,
  100         -
    > {
  101         -
        let input = self
  102         -
            .inner
  103         -
            .build()
  104         -
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
  105         -
        let runtime_plugins = crate::operation::rename_object::RenameObject::operation_runtime_plugins(
  106         -
            self.handle.runtime_plugins.clone(),
  107         -
            &self.handle.conf,
  108         -
            self.config_override,
  109         -
        );
  110         -
        crate::operation::rename_object::RenameObject::orchestrate(&runtime_plugins, input).await
  111         -
    }
  112         -
  113         -
    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
  114         -
    pub fn customize(
  115         -
        self,
  116         -
    ) -> crate::client::customize::CustomizableOperation<
  117         -
        crate::operation::rename_object::RenameObjectOutput,
  118         -
        crate::operation::rename_object::RenameObjectError,
  119         -
        Self,
  120         -
    > {
  121         -
        crate::client::customize::CustomizableOperation::new(self)
  122         -
    }
  123         -
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
  124         -
        self.set_config_override(::std::option::Option::Some(config_override.into()));
  125         -
        self
  126         -
    }
  127         -
  128         -
    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
  129         -
        self.config_override = config_override;
  130         -
        self
  131         -
    }
  132         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  133         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  134         -
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  135         -
        self.inner = self.inner.bucket(input.into());
  136         -
        self
  137         -
    }
  138         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  139         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  140         -
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  141         -
        self.inner = self.inner.set_bucket(input);
  142         -
        self
  143         -
    }
  144         -
    /// <p>The bucket name of the directory bucket containing the object.</p>
  145         -
    /// <p>You must use virtual-hosted-style requests in the format <code>Bucket-name.s3express-zone-id.region-code.amazonaws.com</code>. Path-style requests are not supported. Directory bucket names must be unique in the chosen Availability Zone. Bucket names must follow the format <code>bucket-base-name--zone-id--x-s3 </code> (for example, <code>amzn-s3-demo-bucket--usw2-az1--x-s3</code>). For information about bucket naming restrictions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html">Directory bucket naming rules</a> in the <i>Amazon S3 User Guide</i>.</p>
  146         -
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  147         -
        self.inner.get_bucket()
  148         -
    }
  149         -
    /// <p>Key name of the object to rename.</p>
  150         -
    pub fn key(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  151         -
        self.inner = self.inner.key(input.into());
  152         -
        self
  153         -
    }
  154         -
    /// <p>Key name of the object to rename.</p>
  155         -
    pub fn set_key(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  156         -
        self.inner = self.inner.set_key(input);
  157         -
        self
  158         -
    }
  159         -
    /// <p>Key name of the object to rename.</p>
  160         -
    pub fn get_key(&self) -> &::std::option::Option<::std::string::String> {
  161         -
        self.inner.get_key()
  162         -
    }
  163         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  164         -
    pub fn rename_source(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  165         -
        self.inner = self.inner.rename_source(input.into());
  166         -
        self
  167         -
    }
  168         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  169         -
    pub fn set_rename_source(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  170         -
        self.inner = self.inner.set_rename_source(input);
  171         -
        self
  172         -
    }
  173         -
    /// <p>Specifies the source for the rename operation. The value must be URL encoded.</p>
  174         -
    pub fn get_rename_source(&self) -> &::std::option::Option<::std::string::String> {
  175         -
        self.inner.get_rename_source()
  176         -
    }
  177         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  178         -
    /// <p>Expects the ETag value as a string.</p>
  179         -
    pub fn destination_if_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  180         -
        self.inner = self.inner.destination_if_match(input.into());
  181         -
        self
  182         -
    }
  183         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  184         -
    /// <p>Expects the ETag value as a string.</p>
  185         -
    pub fn set_destination_if_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  186         -
        self.inner = self.inner.set_destination_if_match(input);
  187         -
        self
  188         -
    }
  189         -
    /// <p>Renames the object only if the ETag (entity tag) value provided during the operation matches the ETag of the object in S3. The <code>If-Match</code> header field makes the request method conditional on ETags. If the ETag values do not match, the operation returns a <code>412 Precondition Failed</code> error.</p>
  190         -
    /// <p>Expects the ETag value as a string.</p>
  191         -
    pub fn get_destination_if_match(&self) -> &::std::option::Option<::std::string::String> {
  192         -
        self.inner.get_destination_if_match()
  193         -
    }
  194         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  195         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  196         -
    pub fn destination_if_none_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  197         -
        self.inner = self.inner.destination_if_none_match(input.into());
  198         -
        self
  199         -
    }
  200         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  201         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  202         -
    pub fn set_destination_if_none_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  203         -
        self.inner = self.inner.set_destination_if_none_match(input);
  204         -
        self
  205         -
    }
  206         -
    /// <p>Renames the object only if the destination does not already exist in the specified directory bucket. If the object does exist when you send a request with <code>If-None-Match:*</code>, the S3 API will return a <code>412 Precondition Failed</code> error, preventing an overwrite. The <code>If-None-Match</code> header prevents overwrites of existing data by validating that there's not an object with the same key name already in your directory bucket.</p>
  207         -
    /// <p>Expects the <code>*</code> character (asterisk).</p>
  208         -
    pub fn get_destination_if_none_match(&self) -> &::std::option::Option<::std::string::String> {
  209         -
        self.inner.get_destination_if_none_match()
  210         -
    }
  211         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  212         -
    pub fn destination_if_modified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  213         -
        self.inner = self.inner.destination_if_modified_since(input);
  214         -
        self
  215         -
    }
  216         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  217         -
    pub fn set_destination_if_modified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  218         -
        self.inner = self.inner.set_destination_if_modified_since(input);
  219         -
        self
  220         -
    }
  221         -
    /// <p>Renames the object if the destination exists and if it has been modified since the specified time.</p>
  222         -
    pub fn get_destination_if_modified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  223         -
        self.inner.get_destination_if_modified_since()
  224         -
    }
  225         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  226         -
    pub fn destination_if_unmodified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  227         -
        self.inner = self.inner.destination_if_unmodified_since(input);
  228         -
        self
  229         -
    }
  230         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  231         -
    pub fn set_destination_if_unmodified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  232         -
        self.inner = self.inner.set_destination_if_unmodified_since(input);
  233         -
        self
  234         -
    }
  235         -
    /// <p>Renames the object if it hasn't been modified since the specified time.</p>
  236         -
    pub fn get_destination_if_unmodified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  237         -
        self.inner.get_destination_if_unmodified_since()
  238         -
    }
  239         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  240         -
    pub fn source_if_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  241         -
        self.inner = self.inner.source_if_match(input.into());
  242         -
        self
  243         -
    }
  244         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  245         -
    pub fn set_source_if_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  246         -
        self.inner = self.inner.set_source_if_match(input);
  247         -
        self
  248         -
    }
  249         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) matches the specified ETag.</p>
  250         -
    pub fn get_source_if_match(&self) -> &::std::option::Option<::std::string::String> {
  251         -
        self.inner.get_source_if_match()
  252         -
    }
  253         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  254         -
    pub fn source_if_none_match(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  255         -
        self.inner = self.inner.source_if_none_match(input.into());
  256         -
        self
  257         -
    }
  258         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  259         -
    pub fn set_source_if_none_match(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  260         -
        self.inner = self.inner.set_source_if_none_match(input);
  261         -
        self
  262         -
    }
  263         -
    /// <p>Renames the object if the source exists and if its entity tag (ETag) is different than the specified ETag. If an asterisk (<code>*</code>) character is provided, the operation will fail and return a <code>412 Precondition Failed</code> error.</p>
  264         -
    pub fn get_source_if_none_match(&self) -> &::std::option::Option<::std::string::String> {
  265         -
        self.inner.get_source_if_none_match()
  266         -
    }
  267         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  268         -
    pub fn source_if_modified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  269         -
        self.inner = self.inner.source_if_modified_since(input);
  270         -
        self
  271         -
    }
  272         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  273         -
    pub fn set_source_if_modified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  274         -
        self.inner = self.inner.set_source_if_modified_since(input);
  275         -
        self
  276         -
    }
  277         -
    /// <p>Renames the object if the source exists and if it has been modified since the specified time.</p>
  278         -
    pub fn get_source_if_modified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  279         -
        self.inner.get_source_if_modified_since()
  280         -
    }
  281         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  282         -
    pub fn source_if_unmodified_since(mut self, input: ::aws_smithy_types::DateTime) -> Self {
  283         -
        self.inner = self.inner.source_if_unmodified_since(input);
  284         -
        self
  285         -
    }
  286         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  287         -
    pub fn set_source_if_unmodified_since(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
  288         -
        self.inner = self.inner.set_source_if_unmodified_since(input);
  289         -
        self
  290         -
    }
  291         -
    /// <p>Renames the object if the source exists and hasn't been modified since the specified time.</p>
  292         -
    pub fn get_source_if_unmodified_since(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
  293         -
        self.inner.get_source_if_unmodified_since()
  294         -
    }
  295         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  296         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  297         -
    /// </note>
  298         -
    pub fn client_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  299         -
        self.inner = self.inner.client_token(input.into());
  300         -
        self
  301         -
    }
  302         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  303         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  304         -
    /// </note>
  305         -
    pub fn set_client_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  306         -
        self.inner = self.inner.set_client_token(input);
  307         -
        self
  308         -
    }
  309         -
    /// <p>A unique string with a max of 64 ASCII characters in the ASCII range of 33 - 126.</p><note>
  310         -
    /// <p><code>RenameObject</code> supports idempotency using a client token. To make an idempotent API request using <code>RenameObject</code>, specify a client token in the request. You should not reuse the same client token for other API requests. If you retry a request that completed successfully using the same client token and the same parameters, the retry succeeds without performing any further actions. If you retry a successful request using the same client token, but one or more of the parameters are different, the retry fails and an <code>IdempotentParameterMismatch</code> error is returned.</p>
  311         -
    /// </note>
  312         -
    pub fn get_client_token(&self) -> &::std::option::Option<::std::string::String> {
  313         -
        self.inner.get_client_token()
  314         -
    }
  315         -
}