AWS SDK

AWS SDK

rev. e6785b15a6b118e5a6960c94143c0d982a485bbb

Files changed:

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

@@ -40,40 +148,141 @@
   60     60   
    /// <p>The language the content is in.</p>
   61     61   
    pub content_language: ::std::option::Option<::std::string::String>,
   62     62   
    /// <p>A standard MIME type describing the format of the object data.</p>
   63     63   
    pub content_type: ::std::option::Option<::std::string::String>,
   64     64   
    /// <p>The portion of the object returned in the response for a <code>GET</code> request.</p>
   65     65   
    pub content_range: ::std::option::Option<::std::string::String>,
   66     66   
    /// <p>If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.</p><note>
   67     67   
    /// <p>This functionality is not supported for directory buckets.</p>
   68     68   
    /// </note>
   69     69   
    pub website_redirect_location: ::std::option::Option<::std::string::String>,
   70         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
   71         -
    /// <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>
   72         -
    /// </note>
          70  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
   73     71   
    pub server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
   74     72   
    /// <p>A map of metadata to store with the object in S3.</p>
   75     73   
    pub metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
   76     74   
    /// <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>
   77     75   
    /// <p>This functionality is not supported for directory buckets.</p>
   78     76   
    /// </note>
   79     77   
    pub sse_customer_algorithm: ::std::option::Option<::std::string::String>,
   80     78   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to provide the round-trip message integrity verification of the customer-provided encryption key.</p><note>
   81     79   
    /// <p>This functionality is not supported for directory buckets.</p>
   82     80   
    /// </note>
   83     81   
    pub sse_customer_key_md5: ::std::option::Option<::std::string::String>,
   84     82   
    /// <p>If present, indicates the ID of the KMS key that was used for object encryption.</p>
   85     83   
    pub ssekms_key_id: ::std::option::Option<::std::string::String>,
   86     84   
    /// <p>Indicates whether the object uses an S3 Bucket Key for server-side encryption with Key Management Service (KMS) keys (SSE-KMS).</p>
   87     85   
    pub bucket_key_enabled: ::std::option::Option<bool>,
   88     86   
    /// <p>Provides storage class information of the object. Amazon S3 returns this header for all objects except for S3 Standard storage class objects.</p>
   89     87   
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-class-intro.html">Storage Classes</a>.</p><note>
   90     88   
    /// <p><b>Directory buckets </b> - 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>
   91     89   
    /// </note>
   92     90   
    pub storage_class: ::std::option::Option<crate::types::StorageClass>,
   93     91   
    /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
   94     92   
    /// <p>This functionality is not supported for directory buckets.</p>
   95     93   
    /// </note>
   96     94   
    pub request_charged: ::std::option::Option<crate::types::RequestCharged>,
   97     95   
    /// <p>Amazon S3 can return this header if your request involves a bucket that is either a source or a destination in a replication rule.</p>
   98     96   
    /// <p>In replication, you have a source bucket on which you configure replication and destination bucket or buckets where Amazon S3 stores object replicas. When you request an object (<code>GetObject</code>) or object metadata (<code>HeadObject</code>) from these buckets, Amazon S3 will return the <code>x-amz-replication-status</code> header in the response as follows:</p>
   99     97   
    /// <ul>
  100     98   
    /// <li>
  101     99   
    /// <p><b>If requesting an object from the source bucket</b>, Amazon S3 will return the <code>x-amz-replication-status</code> header if the object in your request is eligible for replication.</p>
  102    100   
    /// <p>For example, suppose that in your replication configuration, you specify object prefix <code>TaxDocs</code> requesting Amazon S3 to replicate objects with key prefix <code>TaxDocs</code>. Any objects you upload with this key name prefix, for example <code>TaxDocs/document1.pdf</code>, are eligible for replication. For any object request with this key name prefix, Amazon S3 will return the <code>x-amz-replication-status</code> header with value PENDING, COMPLETED or FAILED indicating object replication status.</p></li>
  103    101   
    /// <li>
  104    102   
    /// <p><b>If requesting an object from a destination bucket</b>, Amazon S3 will return the <code>x-amz-replication-status</code> header with value REPLICA if the object in your request is a replica that Amazon S3 created and there is no replica modification replication in progress.</p></li>
  105    103   
    /// <li>
  106    104   
    /// <p><b>When replicating objects to multiple destination buckets</b>, the <code>x-amz-replication-status</code> header acts differently. The header of the source object will only return a value of COMPLETED when replication is successful to all destinations. The header will remain at value PENDING until replication has completed for all destinations. If one or more destinations fails replication the header will return FAILED.</p></li>
  107    105   
    /// </ul>
  108    106   
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Replication</a>.</p><note>
  109    107   
    /// <p>This functionality is not supported for directory buckets.</p>
  110    108   
    /// </note>
  111    109   
    pub replication_status: ::std::option::Option<crate::types::ReplicationStatus>,
  112    110   
    /// <p>The count of parts this object has. This value is only returned if you specify <code>partNumber</code> in your request and the object was uploaded as a multipart upload.</p>
  113    111   
    pub parts_count: ::std::option::Option<i32>,
  114         -
    /// <p>The number of tags, if any, on the object, when you have the relevant permission to read object tags.</p>
  115         -
    /// <p>You can use <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html">GetObjectTagging</a> to retrieve the tag set associated with an object.</p><note>
  116         -
    /// <p>This functionality is not supported for directory buckets.</p>
  117         -
    /// </note>
  118         -
    pub tag_count: ::std::option::Option<i32>,
  119    112   
    /// <p>The Object Lock mode, if any, that's in effect for this object. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission. For more information about S3 Object Lock, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html">Object Lock</a>.</p><note>
  120    113   
    /// <p>This functionality is not supported for directory buckets.</p>
  121    114   
    /// </note>
  122    115   
    pub object_lock_mode: ::std::option::Option<crate::types::ObjectLockMode>,
  123    116   
    /// <p>The date and time when the Object Lock retention period expires. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission.</p><note>
  124    117   
    /// <p>This functionality is not supported for directory buckets.</p>
  125    118   
    /// </note>
  126    119   
    pub object_lock_retain_until_date: ::std::option::Option<::aws_smithy_types::DateTime>,
  127    120   
    /// <p>Specifies whether a legal hold is in effect for this object. This header is only returned if the requester has the <code>s3:GetObjectLegalHold</code> permission. This header is not returned if the specified version of this object has never had a legal hold applied. For more information about S3 Object Lock, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html">Object Lock</a>.</p><note>
  128    121   
    /// <p>This functionality is not supported for directory buckets.</p>
@@ -220,213 +282,273 @@
  240    233   
    /// <p>The portion of the object returned in the response for a <code>GET</code> request.</p>
  241    234   
    pub fn content_range(&self) -> ::std::option::Option<&str> {
  242    235   
        self.content_range.as_deref()
  243    236   
    }
  244    237   
    /// <p>If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.</p><note>
  245    238   
    /// <p>This functionality is not supported for directory buckets.</p>
  246    239   
    /// </note>
  247    240   
    pub fn website_redirect_location(&self) -> ::std::option::Option<&str> {
  248    241   
        self.website_redirect_location.as_deref()
  249    242   
    }
  250         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  251         -
    /// <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>
  252         -
    /// </note>
         243  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  253    244   
    pub fn server_side_encryption(&self) -> ::std::option::Option<&crate::types::ServerSideEncryption> {
  254    245   
        self.server_side_encryption.as_ref()
  255    246   
    }
  256    247   
    /// <p>A map of metadata to store with the object in S3.</p>
  257    248   
    pub fn metadata(&self) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, ::std::string::String>> {
  258    249   
        self.metadata.as_ref()
  259    250   
    }
  260    251   
    /// <p>If server-side encryption with a customer-provided encryption key was requested, the response will include this header to confirm the encryption algorithm that's used.</p><note>
  261    252   
    /// <p>This functionality is not supported for directory buckets.</p>
  262    253   
    /// </note>
@@ -284,275 +350,334 @@
  304    295   
    /// <p>For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/NotificationHowTo.html">Replication</a>.</p><note>
  305    296   
    /// <p>This functionality is not supported for directory buckets.</p>
  306    297   
    /// </note>
  307    298   
    pub fn replication_status(&self) -> ::std::option::Option<&crate::types::ReplicationStatus> {
  308    299   
        self.replication_status.as_ref()
  309    300   
    }
  310    301   
    /// <p>The count of parts this object has. This value is only returned if you specify <code>partNumber</code> in your request and the object was uploaded as a multipart upload.</p>
  311    302   
    pub fn parts_count(&self) -> ::std::option::Option<i32> {
  312    303   
        self.parts_count
  313    304   
    }
  314         -
    /// <p>The number of tags, if any, on the object, when you have the relevant permission to read object tags.</p>
  315         -
    /// <p>You can use <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html">GetObjectTagging</a> to retrieve the tag set associated with an object.</p><note>
  316         -
    /// <p>This functionality is not supported for directory buckets.</p>
  317         -
    /// </note>
  318         -
    pub fn tag_count(&self) -> ::std::option::Option<i32> {
  319         -
        self.tag_count
  320         -
    }
  321    305   
    /// <p>The Object Lock mode, if any, that's in effect for this object. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission. For more information about S3 Object Lock, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html">Object Lock</a>.</p><note>
  322    306   
    /// <p>This functionality is not supported for directory buckets.</p>
  323    307   
    /// </note>
  324    308   
    pub fn object_lock_mode(&self) -> ::std::option::Option<&crate::types::ObjectLockMode> {
  325    309   
        self.object_lock_mode.as_ref()
  326    310   
    }
  327    311   
    /// <p>The date and time when the Object Lock retention period expires. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission.</p><note>
  328    312   
    /// <p>This functionality is not supported for directory buckets.</p>
  329    313   
    /// </note>
  330    314   
    pub fn object_lock_retain_until_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
@@ -355,339 +415,398 @@
  375    359   
        formatter.field("server_side_encryption", &self.server_side_encryption);
  376    360   
        formatter.field("metadata", &self.metadata);
  377    361   
        formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
  378    362   
        formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
  379    363   
        formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
  380    364   
        formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
  381    365   
        formatter.field("storage_class", &self.storage_class);
  382    366   
        formatter.field("request_charged", &self.request_charged);
  383    367   
        formatter.field("replication_status", &self.replication_status);
  384    368   
        formatter.field("parts_count", &self.parts_count);
  385         -
        formatter.field("tag_count", &self.tag_count);
  386    369   
        formatter.field("object_lock_mode", &self.object_lock_mode);
  387    370   
        formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
  388    371   
        formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
  389    372   
        formatter.field("expires", &self.expires);
  390    373   
        formatter.field("expires_string", &self.expires_string);
  391    374   
        formatter.field("_extended_request_id", &self._extended_request_id);
  392    375   
        formatter.field("_request_id", &self._request_id);
  393    376   
        formatter.finish()
  394    377   
    }
  395    378   
}
@@ -420,403 +480,462 @@
  440    423   
    pub(crate) server_side_encryption: ::std::option::Option<crate::types::ServerSideEncryption>,
  441    424   
    pub(crate) metadata: ::std::option::Option<::std::collections::HashMap<::std::string::String, ::std::string::String>>,
  442    425   
    pub(crate) sse_customer_algorithm: ::std::option::Option<::std::string::String>,
  443    426   
    pub(crate) sse_customer_key_md5: ::std::option::Option<::std::string::String>,
  444    427   
    pub(crate) ssekms_key_id: ::std::option::Option<::std::string::String>,
  445    428   
    pub(crate) bucket_key_enabled: ::std::option::Option<bool>,
  446    429   
    pub(crate) storage_class: ::std::option::Option<crate::types::StorageClass>,
  447    430   
    pub(crate) request_charged: ::std::option::Option<crate::types::RequestCharged>,
  448    431   
    pub(crate) replication_status: ::std::option::Option<crate::types::ReplicationStatus>,
  449    432   
    pub(crate) parts_count: ::std::option::Option<i32>,
  450         -
    pub(crate) tag_count: ::std::option::Option<i32>,
  451    433   
    pub(crate) object_lock_mode: ::std::option::Option<crate::types::ObjectLockMode>,
  452    434   
    pub(crate) object_lock_retain_until_date: ::std::option::Option<::aws_smithy_types::DateTime>,
  453    435   
    pub(crate) object_lock_legal_hold_status: ::std::option::Option<crate::types::ObjectLockLegalHoldStatus>,
  454    436   
    pub(crate) expires: ::std::option::Option<::aws_smithy_types::DateTime>,
  455    437   
    pub(crate) expires_string: ::std::option::Option<::std::string::String>,
  456    438   
    _extended_request_id: Option<String>,
  457    439   
    _request_id: Option<String>,
  458    440   
}
  459    441   
impl HeadObjectOutputBuilder {
  460    442   
    /// <p>Specifies whether the object retrieved was (true) or was not (false) a Delete Marker. If false, this response header does not appear in the response.</p><note>
@@ -806,788 +882,858 @@
  826    808   
    pub fn set_website_redirect_location(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  827    809   
        self.website_redirect_location = input;
  828    810   
        self
  829    811   
    }
  830    812   
    /// <p>If the bucket is configured as a website, redirects requests for this object to another object in the same bucket or to an external URL. Amazon S3 stores the value of this header in the object metadata.</p><note>
  831    813   
    /// <p>This functionality is not supported for directory buckets.</p>
  832    814   
    /// </note>
  833    815   
    pub fn get_website_redirect_location(&self) -> &::std::option::Option<::std::string::String> {
  834    816   
        &self.website_redirect_location
  835    817   
    }
  836         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  837         -
    /// <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>
  838         -
    /// </note>
         818  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  839    819   
    pub fn server_side_encryption(mut self, input: crate::types::ServerSideEncryption) -> Self {
  840    820   
        self.server_side_encryption = ::std::option::Option::Some(input);
  841    821   
        self
  842    822   
    }
  843         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  844         -
    /// <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>
  845         -
    /// </note>
         823  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  846    824   
    pub fn set_server_side_encryption(mut self, input: ::std::option::Option<crate::types::ServerSideEncryption>) -> Self {
  847    825   
        self.server_side_encryption = input;
  848    826   
        self
  849    827   
    }
  850         -
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 or Amazon FSx.</p><note>
  851         -
    /// <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>
  852         -
    /// </note>
         828  +
    /// <p>The server-side encryption algorithm used when you store this object in Amazon S3 (for example, <code>AES256</code>, <code>aws:kms</code>, <code>aws:kms:dsse</code>).</p>
  853    829   
    pub fn get_server_side_encryption(&self) -> &::std::option::Option<crate::types::ServerSideEncryption> {
  854    830   
        &self.server_side_encryption
  855    831   
    }
  856    832   
    /// Adds a key-value pair to `metadata`.
  857    833   
    ///
  858    834   
    /// To override the contents of this collection use [`set_metadata`](Self::set_metadata).
  859    835   
    ///
  860    836   
    /// <p>A map of metadata to store with the object in S3.</p>
  861    837   
    pub fn metadata(mut self, k: impl ::std::convert::Into<::std::string::String>, v: impl ::std::convert::Into<::std::string::String>) -> Self {
  862    838   
        let mut hash_map = self.metadata.unwrap_or_default();
@@ -1024,1000 +1106,1059 @@
 1044   1020   
    }
 1045   1021   
    /// <p>The count of parts this object has. This value is only returned if you specify <code>partNumber</code> in your request and the object was uploaded as a multipart upload.</p>
 1046   1022   
    pub fn set_parts_count(mut self, input: ::std::option::Option<i32>) -> Self {
 1047   1023   
        self.parts_count = input;
 1048   1024   
        self
 1049   1025   
    }
 1050   1026   
    /// <p>The count of parts this object has. This value is only returned if you specify <code>partNumber</code> in your request and the object was uploaded as a multipart upload.</p>
 1051   1027   
    pub fn get_parts_count(&self) -> &::std::option::Option<i32> {
 1052   1028   
        &self.parts_count
 1053   1029   
    }
 1054         -
    /// <p>The number of tags, if any, on the object, when you have the relevant permission to read object tags.</p>
 1055         -
    /// <p>You can use <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html">GetObjectTagging</a> to retrieve the tag set associated with an object.</p><note>
 1056         -
    /// <p>This functionality is not supported for directory buckets.</p>
 1057         -
    /// </note>
 1058         -
    pub fn tag_count(mut self, input: i32) -> Self {
 1059         -
        self.tag_count = ::std::option::Option::Some(input);
 1060         -
        self
 1061         -
    }
 1062         -
    /// <p>The number of tags, if any, on the object, when you have the relevant permission to read object tags.</p>
 1063         -
    /// <p>You can use <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html">GetObjectTagging</a> to retrieve the tag set associated with an object.</p><note>
 1064         -
    /// <p>This functionality is not supported for directory buckets.</p>
 1065         -
    /// </note>
 1066         -
    pub fn set_tag_count(mut self, input: ::std::option::Option<i32>) -> Self {
 1067         -
        self.tag_count = input;
 1068         -
        self
 1069         -
    }
 1070         -
    /// <p>The number of tags, if any, on the object, when you have the relevant permission to read object tags.</p>
 1071         -
    /// <p>You can use <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObjectTagging.html">GetObjectTagging</a> to retrieve the tag set associated with an object.</p><note>
 1072         -
    /// <p>This functionality is not supported for directory buckets.</p>
 1073         -
    /// </note>
 1074         -
    pub fn get_tag_count(&self) -> &::std::option::Option<i32> {
 1075         -
        &self.tag_count
 1076         -
    }
 1077   1030   
    /// <p>The Object Lock mode, if any, that's in effect for this object. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission. For more information about S3 Object Lock, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html">Object Lock</a>.</p><note>
 1078   1031   
    /// <p>This functionality is not supported for directory buckets.</p>
 1079   1032   
    /// </note>
 1080   1033   
    pub fn object_lock_mode(mut self, input: crate::types::ObjectLockMode) -> Self {
 1081   1034   
        self.object_lock_mode = ::std::option::Option::Some(input);
 1082   1035   
        self
 1083   1036   
    }
 1084   1037   
    /// <p>The Object Lock mode, if any, that's in effect for this object. This header is only returned if the requester has the <code>s3:GetObjectRetention</code> permission. For more information about S3 Object Lock, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/object-lock.html">Object Lock</a>.</p><note>
 1085   1038   
    /// <p>This functionality is not supported for directory buckets.</p>
 1086   1039   
    /// </note>
@@ -1192,1145 +1279,1230 @@
 1212   1165   
            server_side_encryption: self.server_side_encryption,
 1213   1166   
            metadata: self.metadata,
 1214   1167   
            sse_customer_algorithm: self.sse_customer_algorithm,
 1215   1168   
            sse_customer_key_md5: self.sse_customer_key_md5,
 1216   1169   
            ssekms_key_id: self.ssekms_key_id,
 1217   1170   
            bucket_key_enabled: self.bucket_key_enabled,
 1218   1171   
            storage_class: self.storage_class,
 1219   1172   
            request_charged: self.request_charged,
 1220   1173   
            replication_status: self.replication_status,
 1221   1174   
            parts_count: self.parts_count,
 1222         -
            tag_count: self.tag_count,
 1223   1175   
            object_lock_mode: self.object_lock_mode,
 1224   1176   
            object_lock_retain_until_date: self.object_lock_retain_until_date,
 1225   1177   
            object_lock_legal_hold_status: self.object_lock_legal_hold_status,
 1226   1178   
            expires: self.expires,
 1227   1179   
            expires_string: self.expires_string,
 1228   1180   
            _extended_request_id: self._extended_request_id,
 1229   1181   
            _request_id: self._request_id,
 1230   1182   
        }
 1231   1183   
    }
 1232   1184   
}
 1233   1185   
impl ::std::fmt::Debug for HeadObjectOutputBuilder {
 1234   1186   
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
 1235   1187   
        let mut formatter = f.debug_struct("HeadObjectOutputBuilder");
 1236   1188   
        formatter.field("delete_marker", &self.delete_marker);
 1237   1189   
        formatter.field("accept_ranges", &self.accept_ranges);
 1238   1190   
        formatter.field("expiration", &self.expiration);
 1239   1191   
        formatter.field("restore", &self.restore);
 1240   1192   
        formatter.field("archive_status", &self.archive_status);
 1241   1193   
        formatter.field("last_modified", &self.last_modified);
 1242   1194   
        formatter.field("content_length", &self.content_length);
 1243   1195   
        formatter.field("checksum_crc32", &self.checksum_crc32);
 1244   1196   
        formatter.field("checksum_crc32_c", &self.checksum_crc32_c);
 1245   1197   
        formatter.field("checksum_crc64_nvme", &self.checksum_crc64_nvme);
 1246   1198   
        formatter.field("checksum_sha1", &self.checksum_sha1);
 1247   1199   
        formatter.field("checksum_sha256", &self.checksum_sha256);
 1248   1200   
        formatter.field("checksum_type", &self.checksum_type);
 1249   1201   
        formatter.field("e_tag", &self.e_tag);
 1250   1202   
        formatter.field("missing_meta", &self.missing_meta);
 1251   1203   
        formatter.field("version_id", &self.version_id);
 1252   1204   
        formatter.field("cache_control", &self.cache_control);
 1253   1205   
        formatter.field("content_disposition", &self.content_disposition);
 1254   1206   
        formatter.field("content_encoding", &self.content_encoding);
 1255   1207   
        formatter.field("content_language", &self.content_language);
 1256   1208   
        formatter.field("content_type", &self.content_type);
 1257   1209   
        formatter.field("content_range", &self.content_range);
 1258   1210   
        formatter.field("website_redirect_location", &self.website_redirect_location);
 1259   1211   
        formatter.field("server_side_encryption", &self.server_side_encryption);
 1260   1212   
        formatter.field("metadata", &self.metadata);
 1261   1213   
        formatter.field("sse_customer_algorithm", &self.sse_customer_algorithm);
 1262   1214   
        formatter.field("sse_customer_key_md5", &self.sse_customer_key_md5);
 1263   1215   
        formatter.field("ssekms_key_id", &"*** Sensitive Data Redacted ***");
 1264   1216   
        formatter.field("bucket_key_enabled", &self.bucket_key_enabled);
 1265   1217   
        formatter.field("storage_class", &self.storage_class);
 1266   1218   
        formatter.field("request_charged", &self.request_charged);
 1267   1219   
        formatter.field("replication_status", &self.replication_status);
 1268   1220   
        formatter.field("parts_count", &self.parts_count);
 1269         -
        formatter.field("tag_count", &self.tag_count);
 1270   1221   
        formatter.field("object_lock_mode", &self.object_lock_mode);
 1271   1222   
        formatter.field("object_lock_retain_until_date", &self.object_lock_retain_until_date);
 1272   1223   
        formatter.field("object_lock_legal_hold_status", &self.object_lock_legal_hold_status);
 1273   1224   
        formatter.field("expires", &self.expires);
 1274   1225   
        formatter.field("expires_string", &self.expires_string);
 1275   1226   
        formatter.field("_extended_request_id", &self._extended_request_id);
 1276   1227   
        formatter.field("_request_id", &self._request_id);
 1277   1228   
        formatter.finish()
 1278   1229   
    }
 1279   1230   
}

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

@@ -205,205 +265,264 @@
  225    225   
                ::std::result::Result::Ok(())
  226    226   
            }
  227    227   
            #[allow(clippy::unnecessary_wraps)]
  228    228   
            fn update_http_builder(
  229    229   
                input: &crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
  230    230   
                builder: ::http::request::Builder,
  231    231   
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  232    232   
                let mut uri = ::std::string::String::new();
  233    233   
                uri_base(input, &mut uri)?;
  234    234   
                uri_query(input, &mut uri)?;
  235         -
                let builder = crate::protocol_serde::shape_list_bucket_intelligent_tiering_configurations::ser_list_bucket_intelligent_tiering_configurations_headers(input, builder)?;
  236    235   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  237    236   
            }
  238    237   
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  239    238   
            builder
  240    239   
        };
  241    240   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  242    241   
  243    242   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  244    243   
    }
  245    244   
}

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

@@ -1,1 +102,80 @@
    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 ListBucketIntelligentTieringConfigurationsInput {
    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 <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
    9      9   
    pub continuation_token: ::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   
}
   13     11   
impl ListBucketIntelligentTieringConfigurationsInput {
   14     12   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   15     13   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   16     14   
        self.bucket.as_deref()
   17     15   
    }
   18     16   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
   19     17   
    pub fn continuation_token(&self) -> ::std::option::Option<&str> {
   20     18   
        self.continuation_token.as_deref()
   21     19   
    }
   22         -
    /// <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>
   23         -
    pub fn expected_bucket_owner(&self) -> ::std::option::Option<&str> {
   24         -
        self.expected_bucket_owner.as_deref()
   25         -
    }
   26     20   
}
   27     21   
impl ListBucketIntelligentTieringConfigurationsInput {
   28     22   
    /// Creates a new builder-style object to manufacture [`ListBucketIntelligentTieringConfigurationsInput`](crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput).
   29     23   
    pub fn builder(
   30     24   
    ) -> crate::operation::list_bucket_intelligent_tiering_configurations::builders::ListBucketIntelligentTieringConfigurationsInputBuilder {
   31     25   
        crate::operation::list_bucket_intelligent_tiering_configurations::builders::ListBucketIntelligentTieringConfigurationsInputBuilder::default()
   32     26   
    }
   33     27   
}
   34     28   
   35     29   
/// A builder for [`ListBucketIntelligentTieringConfigurationsInput`](crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput).
   36     30   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   37     31   
#[non_exhaustive]
   38     32   
pub struct ListBucketIntelligentTieringConfigurationsInputBuilder {
   39     33   
    pub(crate) bucket: ::std::option::Option<::std::string::String>,
   40     34   
    pub(crate) continuation_token: ::std::option::Option<::std::string::String>,
   41         -
    pub(crate) expected_bucket_owner: ::std::option::Option<::std::string::String>,
   42     35   
}
   43     36   
impl ListBucketIntelligentTieringConfigurationsInputBuilder {
   44     37   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   45     38   
    /// This field is required.
   46     39   
    pub fn bucket(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   47     40   
        self.bucket = ::std::option::Option::Some(input.into());
   48     41   
        self
   49     42   
    }
   50     43   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   51     44   
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   52     45   
        self.bucket = input;
   53     46   
        self
   54     47   
    }
   55     48   
    /// <p>The name of the Amazon S3 bucket whose configuration you want to modify or retrieve.</p>
   56     49   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
   57     50   
        &self.bucket
   58     51   
    }
   59     52   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
   60     53   
    pub fn continuation_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   61     54   
        self.continuation_token = ::std::option::Option::Some(input.into());
   62     55   
        self
   63     56   
    }
   64     57   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
   65     58   
    pub fn set_continuation_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   66     59   
        self.continuation_token = input;
   67     60   
        self
   68     61   
    }
   69     62   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
   70     63   
    pub fn get_continuation_token(&self) -> &::std::option::Option<::std::string::String> {
   71     64   
        &self.continuation_token
   72     65   
    }
   73         -
    /// <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>
   74         -
    pub fn expected_bucket_owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   75         -
        self.expected_bucket_owner = ::std::option::Option::Some(input.into());
   76         -
        self
   77         -
    }
   78         -
    /// <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>
   79         -
    pub fn set_expected_bucket_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   80         -
        self.expected_bucket_owner = input;
   81         -
        self
   82         -
    }
   83         -
    /// <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>
   84         -
    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {
   85         -
        &self.expected_bucket_owner
   86         -
    }
   87     66   
    /// Consumes the builder and constructs a [`ListBucketIntelligentTieringConfigurationsInput`](crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput).
   88     67   
    pub fn build(
   89     68   
        self,
   90     69   
    ) -> ::std::result::Result<
   91     70   
        crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput,
   92     71   
        ::aws_smithy_types::error::operation::BuildError,
   93     72   
    > {
   94     73   
        ::std::result::Result::Ok(
   95     74   
            crate::operation::list_bucket_intelligent_tiering_configurations::ListBucketIntelligentTieringConfigurationsInput {
   96     75   
                bucket: self.bucket,
   97     76   
                continuation_token: self.continuation_token,
   98         -
                expected_bucket_owner: self.expected_bucket_owner,
   99     77   
            },
  100     78   
        )
  101     79   
    }
  102     80   
}

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

@@ -131,131 +175,161 @@
  151    151   
    }
  152    152   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
  153    153   
    pub fn set_continuation_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  154    154   
        self.inner = self.inner.set_continuation_token(input);
  155    155   
        self
  156    156   
    }
  157    157   
    /// <p>The <code>ContinuationToken</code> that represents a placeholder from where this request should begin.</p>
  158    158   
    pub fn get_continuation_token(&self) -> &::std::option::Option<::std::string::String> {
  159    159   
        self.inner.get_continuation_token()
  160    160   
    }
  161         -
    /// <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>
  162         -
    pub fn expected_bucket_owner(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  163         -
        self.inner = self.inner.expected_bucket_owner(input.into());
  164         -
        self
  165         -
    }
  166         -
    /// <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>
  167         -
    pub fn set_expected_bucket_owner(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  168         -
        self.inner = self.inner.set_expected_bucket_owner(input);
  169         -
        self
  170         -
    }
  171         -
    /// <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>
  172         -
    pub fn get_expected_bucket_owner(&self) -> &::std::option::Option<::std::string::String> {
  173         -
        self.inner.get_expected_bucket_owner()
  174         -
    }
  175    161   
}

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

@@ -1,1 +58,58 @@
   18     18   
        let mut fluent_builder = client.list_bucket_inventory_configurations();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListBucketInventoryConfigurations`.
   24     24   
///
   25     25   
/// <note>
   26     26   
/// <p>This operation is not supported for directory buckets.</p>
   27     27   
/// </note>
   28         -
/// <p>Returns a list of S3 Inventory configurations for the bucket. You can have up to 1,000 analytics configurations per bucket.</p>
          28  +
/// <p>Returns a list of inventory configurations for the bucket. You can have up to 1,000 analytics configurations per bucket.</p>
   29     29   
/// <p>This action supports list pagination and does not return more than 100 configurations at a time. Always check the <code>IsTruncated</code> element in the response. If there are no more configurations to list, <code>IsTruncated</code> is set to false. If there are more configurations to list, <code>IsTruncated</code> is set to true, and there is a value in <code>NextContinuationToken</code>. You use the <code>NextContinuationToken</code> value to continue the pagination of the list by passing the value in continuation-token in the request to <code>GET</code> the next page.</p>
   30     30   
/// <p>To use this operation, you must have permissions to perform the <code>s3:GetInventoryConfiguration</code> action. The bucket owner has this permission by default. The bucket owner can grant this permission to others. For more information about permissions, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/using-with-s3-actions.html#using-with-s3-actions-related-to-bucket-subresources">Permissions Related to Bucket Subresource Operations</a> and <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html">Managing Access Permissions to Your Amazon S3 Resources</a>.</p>
   31     31   
/// <p>For information about the Amazon S3 inventory feature, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/storage-inventory.html">Amazon S3 Inventory</a></p>
   32     32   
/// <p>The following operations are related to <code>ListBucketInventoryConfigurations</code>:</p>
   33     33   
/// <ul>
   34     34   
/// <li>
   35     35   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketInventoryConfiguration.html">GetBucketInventoryConfiguration</a></p></li>
   36     36   
/// <li>
   37     37   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketInventoryConfiguration.html">DeleteBucketInventoryConfiguration</a></p></li>
   38     38   
/// <li>

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_buckets/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.list_buckets();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListBuckets`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</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>Returns a list of all buckets owned by the authenticated sender of the request. To grant IAM permission to use this operation, you must add the <code>s3:ListAllMyBuckets</code> policy action.</p>
   32     29   
/// <p>For information about Amazon S3 buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/creating-buckets-s3.html">Creating, configuring, and working with Amazon S3 buckets</a>.</p><important>
   33     30   
/// <p>We strongly recommend using only paginated <code>ListBuckets</code> requests. Unpaginated <code>ListBuckets</code> requests are only supported for Amazon Web Services accounts set to the default general purpose bucket quota of 10,000. If you have an approved general purpose bucket quota above 10,000, you must send paginated <code>ListBuckets</code> requests to list your account’s buckets. All unpaginated <code>ListBuckets</code> requests will be rejected for Amazon Web Services accounts with a general purpose bucket quota greater than 10,000.</p>
   34     31   
/// </important>
   35     32   
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
   36     33   
pub struct ListBucketsFluentBuilder {
   37     34   
    handle: ::std::sync::Arc<crate::client::Handle>,
   38     35   
    inner: crate::operation::list_buckets::builders::ListBucketsInputBuilder,

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

@@ -1,1 +94,92 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct ListMultipartUploadsInput {
    6      6   
    /// <p>The name of the bucket to which the multipart upload was initiated.</p>
    7      7   
    /// <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>
    8      8   
    /// <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>
    9      9   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   10     10   
    /// </note>
   11     11   
    /// <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>
   12     12   
    pub bucket: ::std::option::Option<::std::string::String>,
   13     13   
    /// <p>Character you use to group keys.</p>
   14         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
   15         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
          14  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
   16     15   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
   17     16   
    /// </note>
   18     17   
    pub delimiter: ::std::option::Option<::std::string::String>,
   19     18   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   20     19   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   21     20   
    /// </note>
   22     21   
    pub encoding_type: ::std::option::Option<crate::types::EncodingType>,
   23     22   
    /// <p>Specifies the multipart upload after which listing should begin.</p><note>
   24     23   
    /// <ul>
   25     24   
    /// <li>
   26     25   
    /// <p><b>General purpose buckets</b> - For general purpose buckets, <code>key-marker</code> is an object key. Together with <code>upload-id-marker</code>, this parameter specifies the multipart upload after which listing should begin.</p>
   27     26   
    /// <p>If <code>upload-id-marker</code> is not specified, only the keys lexicographically greater than the specified <code>key-marker</code> will be included in the list.</p>
   28     27   
    /// <p>If <code>upload-id-marker</code> is specified, any multipart uploads for a key equal to the <code>key-marker</code> might also be included, provided those multipart uploads have upload IDs lexicographically greater than the specified <code>upload-id-marker</code>.</p></li>
   29     28   
    /// <li>
   30     29   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>key-marker</code> is obfuscated and isn't a real object key. The <code>upload-id-marker</code> parameter isn't supported by directory buckets. To list the additional multipart uploads, you only need to set the value of <code>key-marker</code> to the <code>NextKeyMarker</code> value from the previous response.</p>
   31     30   
    /// <p>In the <code>ListMultipartUploads</code> response, the multipart uploads aren't sorted lexicographically based on the object keys.</p></li>
   32     31   
    /// </ul>
   33     32   
    /// </note>
   34     33   
    pub key_marker: ::std::option::Option<::std::string::String>,
   35     34   
    /// <p>Sets the maximum number of multipart uploads, from 1 to 1,000, to return in the response body. 1,000 is the maximum number of uploads that can be returned in a response.</p>
   36     35   
    pub max_uploads: ::std::option::Option<i32>,
   37     36   
    /// <p>Lists in-progress uploads only for those keys that begin with the specified prefix. You can use prefixes to separate a bucket into different grouping of keys. (You can think of using <code>prefix</code> to make groups in the same way that you'd use a folder in a file system.)</p><note>
   38     37   
    /// <p><b>Directory buckets</b> - For directory buckets, only prefixes that end in a delimiter (<code>/</code>) are supported.</p>
   39     38   
    /// </note>
   40     39   
    pub prefix: ::std::option::Option<::std::string::String>,
   41     40   
    /// <p>Together with key-marker, specifies the multipart upload after which listing should begin. If key-marker is not specified, the upload-id-marker parameter is ignored. Otherwise, any multipart uploads for a key equal to the key-marker might be included in the list only if they have an upload ID lexicographically greater than the specified <code>upload-id-marker</code>.</p><note>
   42     41   
    /// <p>This functionality is not supported for directory buckets.</p>
   43     42   
    /// </note>
   44     43   
    pub upload_id_marker: ::std::option::Option<::std::string::String>,
   45     44   
    /// <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>
   46     45   
    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,
   47     46   
    /// <p>Confirms that the requester knows that they will be charged for the request. Bucket owners need not specify this parameter in their requests. If either the source or destination S3 bucket has Requester Pays enabled, the requester will pay for corresponding charges to copy the object. For information about downloading objects from Requester Pays buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html">Downloading Objects in Requester Pays Buckets</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   48     47   
    /// <p>This functionality is not supported for directory buckets.</p>
   49     48   
    /// </note>
   50     49   
    pub request_payer: ::std::option::Option<crate::types::RequestPayer>,
   51     50   
}
   52     51   
impl ListMultipartUploadsInput {
   53     52   
    /// <p>The name of the bucket to which the multipart upload was initiated.</p>
   54     53   
    /// <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>
   55     54   
    /// <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>
   56     55   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   57     56   
    /// </note>
   58     57   
    /// <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>
   59     58   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   60     59   
        self.bucket.as_deref()
   61     60   
    }
   62     61   
    /// <p>Character you use to group keys.</p>
   63         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
   64         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
          62  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
   65     63   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
   66     64   
    /// </note>
   67     65   
    pub fn delimiter(&self) -> ::std::option::Option<&str> {
   68     66   
        self.delimiter.as_deref()
   69     67   
    }
   70     68   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   71     69   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   72     70   
    /// </note>
   73     71   
    pub fn encoding_type(&self) -> ::std::option::Option<&crate::types::EncodingType> {
   74     72   
        self.encoding_type.as_ref()
@@ -140,138 +219,214 @@
  160    158   
    /// <p>The name of the bucket to which the multipart upload was initiated.</p>
  161    159   
    /// <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>
  162    160   
    /// <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>
  163    161   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  164    162   
    /// </note>
  165    163   
    /// <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>
  166    164   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  167    165   
        &self.bucket
  168    166   
    }
  169    167   
    /// <p>Character you use to group keys.</p>
  170         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  171         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         168  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  172    169   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  173    170   
    /// </note>
  174    171   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  175    172   
        self.delimiter = ::std::option::Option::Some(input.into());
  176    173   
        self
  177    174   
    }
  178    175   
    /// <p>Character you use to group keys.</p>
  179         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  180         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         176  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  181    177   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  182    178   
    /// </note>
  183    179   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  184    180   
        self.delimiter = input;
  185    181   
        self
  186    182   
    }
  187    183   
    /// <p>Character you use to group keys.</p>
  188         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  189         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         184  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  190    185   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  191    186   
    /// </note>
  192    187   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  193    188   
        &self.delimiter
  194    189   
    }
  195    190   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  196    191   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  197    192   
    /// </note>
  198    193   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  199    194   
        self.encoding_type = ::std::option::Option::Some(input);

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_multipart_uploads/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.list_multipart_uploads();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListMultipartUploads`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</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>This operation lists in-progress multipart uploads in a bucket. An in-progress multipart upload is a multipart upload that has been initiated by the <code>CreateMultipartUpload</code> request, but has not yet been completed or aborted.</p><note>
   30     26   
/// <p><b>Directory buckets</b> - If multipart uploads in a directory bucket are in progress, you can't delete the bucket until all the in-progress multipart uploads are aborted or completed. To delete these in-progress multipart uploads, use the <code>ListMultipartUploads</code> operation to list the in-progress multipart uploads in the bucket and use the <code>AbortMultipartUpload</code> operation to abort all the in-progress multipart uploads.</p>
   31     27   
/// </note>
   32     28   
/// <p>The <code>ListMultipartUploads</code> operation returns a maximum of 1,000 multipart uploads in the response. The limit of 1,000 multipart uploads is also the default value. You can further limit the number of uploads in a response by specifying the <code>max-uploads</code> request parameter. If there are more than 1,000 multipart uploads that satisfy your <code>ListMultipartUploads</code> request, the response returns an <code>IsTruncated</code> element with the value of <code>true</code>, a <code>NextKeyMarker</code> element, and a <code>NextUploadIdMarker</code> element. To list the remaining multipart uploads, you need to make subsequent <code>ListMultipartUploads</code> requests. In these requests, include two query parameters: <code>key-marker</code> and <code>upload-id-marker</code>. Set the value of <code>key-marker</code> to the <code>NextKeyMarker</code> value from the previous response. Similarly, set the value of <code>upload-id-marker</code> to the <code>NextUploadIdMarker</code> value from the previous response.</p><note>
   33     29   
/// <p><b>Directory buckets</b> - The <code>upload-id-marker</code> element and the <code>NextUploadIdMarker</code> element aren't supported by directory buckets. To list the additional multipart uploads, you only need to set the value of <code>key-marker</code> to the <code>NextKeyMarker</code> value from the previous response.</p>
   34     30   
/// </note>
   35     31   
/// <p>For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html">Uploading Objects Using Multipart Upload</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   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>
   37     33   
/// </note>
   38     34   
/// <dl>
@@ -172,168 +251,244 @@
  192    188   
    /// <p>The name of the bucket to which the multipart upload was initiated.</p>
  193    189   
    /// <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>
  194    190   
    /// <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>
  195    191   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  196    192   
    /// </note>
  197    193   
    /// <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>
  198    194   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  199    195   
        self.inner.get_bucket()
  200    196   
    }
  201    197   
    /// <p>Character you use to group keys.</p>
  202         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  203         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         198  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  204    199   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  205    200   
    /// </note>
  206    201   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  207    202   
        self.inner = self.inner.delimiter(input.into());
  208    203   
        self
  209    204   
    }
  210    205   
    /// <p>Character you use to group keys.</p>
  211         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  212         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         206  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  213    207   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  214    208   
    /// </note>
  215    209   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  216    210   
        self.inner = self.inner.set_delimiter(input);
  217    211   
        self
  218    212   
    }
  219    213   
    /// <p>Character you use to group keys.</p>
  220         -
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p>
  221         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p><note>
         214  +
    /// <p>All keys that contain the same string between the prefix, if specified, and the first occurrence of the delimiter after the prefix are grouped under a single result element, <code>CommonPrefixes</code>. If you don't specify the prefix parameter, then the substring starts at the beginning of the key. The keys that are grouped under <code>CommonPrefixes</code> result element are not returned elsewhere in the response.</p><note>
  222    215   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p>
  223    216   
    /// </note>
  224    217   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  225    218   
        self.inner.get_delimiter()
  226    219   
    }
  227    220   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  228    221   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  229    222   
    /// </note>
  230    223   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  231    224   
        self.inner = self.inner.encoding_type(input);

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

@@ -1,1 +70,68 @@
    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 ListObjectVersionsInput {
    6      6   
    /// <p>The bucket name that contains the objects.</p>
    7      7   
    pub bucket: ::std::option::Option<::std::string::String>,
    8      8   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
    9         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
   10      9   
    pub delimiter: ::std::option::Option<::std::string::String>,
   11     10   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   12     11   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   13     12   
    /// </note>
   14     13   
    pub encoding_type: ::std::option::Option<crate::types::EncodingType>,
   15     14   
    /// <p>Specifies the key to start with when listing objects in a bucket.</p>
   16     15   
    pub key_marker: ::std::option::Option<::std::string::String>,
   17     16   
    /// <p>Sets the maximum number of keys returned in the response. By default, the action returns up to 1,000 key names. The response might contain fewer keys but will never contain more. If additional keys satisfy the search criteria, but were not returned because <code>max-keys</code> was exceeded, the response contains <code><istruncated>
   18     17   
    /// true
   19     18   
    /// </istruncated></code>. To return the additional keys, see <code>key-marker</code> and <code>version-id-marker</code>.</p>
   20     19   
    pub max_keys: ::std::option::Option<i32>,
   21     20   
    /// <p>Use this parameter to select only those keys that begin with the specified prefix. You can use prefixes to separate a bucket into different groupings of keys. (You can think of using <code>prefix</code> to make groups in the same way that you'd use a folder in a file system.) You can use <code>prefix</code> with <code>delimiter</code> to roll up numerous objects into a single result under <code>CommonPrefixes</code>.</p>
   22     21   
    pub prefix: ::std::option::Option<::std::string::String>,
   23     22   
    /// <p>Specifies the object version you want to start listing from.</p>
   24     23   
    pub version_id_marker: ::std::option::Option<::std::string::String>,
   25     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>
   26     25   
    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,
   27     26   
    /// <p>Confirms that the requester knows that they will be charged for the request. Bucket owners need not specify this parameter in their requests. If either the source or destination S3 bucket has Requester Pays enabled, the requester will pay for corresponding charges to copy the object. For information about downloading objects from Requester Pays buckets, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/ObjectsinRequesterPaysBuckets.html">Downloading Objects in Requester Pays Buckets</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   28     27   
    /// <p>This functionality is not supported for directory buckets.</p>
   29     28   
    /// </note>
   30     29   
    pub request_payer: ::std::option::Option<crate::types::RequestPayer>,
   31     30   
    /// <p>Specifies the optional fields that you want returned in the response. Fields that you do not specify are not returned.</p>
   32     31   
    pub optional_object_attributes: ::std::option::Option<::std::vec::Vec<crate::types::OptionalObjectAttributes>>,
   33     32   
}
   34     33   
impl ListObjectVersionsInput {
   35     34   
    /// <p>The bucket name that contains the objects.</p>
   36     35   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   37     36   
        self.bucket.as_deref()
   38     37   
    }
   39     38   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
   40         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
   41     39   
    pub fn delimiter(&self) -> ::std::option::Option<&str> {
   42     40   
        self.delimiter.as_deref()
   43     41   
    }
   44     42   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   45     43   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   46     44   
    /// </note>
   47     45   
    pub fn encoding_type(&self) -> ::std::option::Option<&crate::types::EncodingType> {
   48     46   
        self.encoding_type.as_ref()
   49     47   
    }
   50     48   
    /// <p>Specifies the key to start with when listing objects in a bucket.</p>
@@ -94,92 +166,161 @@
  114    112   
    /// <p>The bucket name that contains the objects.</p>
  115    113   
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  116    114   
        self.bucket = input;
  117    115   
        self
  118    116   
    }
  119    117   
    /// <p>The bucket name that contains the objects.</p>
  120    118   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  121    119   
        &self.bucket
  122    120   
    }
  123    121   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  124         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  125    122   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  126    123   
        self.delimiter = ::std::option::Option::Some(input.into());
  127    124   
        self
  128    125   
    }
  129    126   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  130         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  131    127   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  132    128   
        self.delimiter = input;
  133    129   
        self
  134    130   
    }
  135    131   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  136         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  137    132   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  138    133   
        &self.delimiter
  139    134   
    }
  140    135   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  141    136   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  142    137   
    /// </note>
  143    138   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  144    139   
        self.encoding_type = ::std::option::Option::Some(input);
  145    140   
        self
  146    141   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_object_versions/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.list_object_versions();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListObjectVersions`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</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>Returns metadata about all versions of the objects in a bucket. You can also use request parameters as selection criteria to return metadata about a subset of all the object versions.</p><important>
   32     29   
/// <p>To use this operation, you must have permission to perform the <code>s3:ListBucketVersions</code> action. Be aware of the name difference.</p>
   33     30   
/// </important> <note>
   34     31   
/// <p>A <code>200 OK</code> response can contain valid or invalid XML. Make sure to design your application to parse the contents of the response and handle it appropriately.</p>
   35     32   
/// </note>
   36     33   
/// <p>To use this operation, you must have READ access to the bucket.</p>
   37     34   
/// <p>The following operations are related to <code>ListObjectVersions</code>:</p>
   38     35   
/// <ul>
@@ -118,115 +190,184 @@
  138    135   
    /// <p>The bucket name that contains the objects.</p>
  139    136   
    pub fn set_bucket(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  140    137   
        self.inner = self.inner.set_bucket(input);
  141    138   
        self
  142    139   
    }
  143    140   
    /// <p>The bucket name that contains the objects.</p>
  144    141   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  145    142   
        self.inner.get_bucket()
  146    143   
    }
  147    144   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  148         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  149    145   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  150    146   
        self.inner = self.inner.delimiter(input.into());
  151    147   
        self
  152    148   
    }
  153    149   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  154         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  155    150   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  156    151   
        self.inner = self.inner.set_delimiter(input);
  157    152   
        self
  158    153   
    }
  159    154   
    /// <p>A delimiter is a character that you specify to group keys. All keys that contain the same string between the <code>prefix</code> and the first occurrence of the delimiter are grouped under a single result element in <code>CommonPrefixes</code>. These groups are counted as one result against the <code>max-keys</code> limitation. These keys are not returned elsewhere in the response.</p>
  160         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  161    155   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  162    156   
        self.inner.get_delimiter()
  163    157   
    }
  164    158   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  165    159   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  166    160   
    /// </note>
  167    161   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  168    162   
        self.inner = self.inner.encoding_type(input);
  169    163   
        self
  170    164   
    }

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

@@ -1,1 +74,72 @@
    4      4   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    5      5   
pub struct ListObjectsInput {
    6      6   
    /// <p>The name of the bucket containing the objects.</p>
    7      7   
    /// <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>
    8      8   
    /// <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>
    9      9   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   10     10   
    /// </note>
   11     11   
    /// <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>
   12     12   
    pub bucket: ::std::option::Option<::std::string::String>,
   13     13   
    /// <p>A delimiter is a character that you use to group keys.</p>
   14         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
   15     14   
    pub delimiter: ::std::option::Option<::std::string::String>,
   16     15   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   17     16   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   18     17   
    /// </note>
   19     18   
    pub encoding_type: ::std::option::Option<crate::types::EncodingType>,
   20     19   
    /// <p>Marker is where you want Amazon S3 to start listing from. Amazon S3 starts listing after this specified key. Marker can be any key in the bucket.</p>
   21     20   
    pub marker: ::std::option::Option<::std::string::String>,
   22     21   
    /// <p>Sets the maximum number of keys returned in the response. By default, the action returns up to 1,000 key names. The response might contain fewer keys but will never contain more.</p>
   23     22   
    pub max_keys: ::std::option::Option<i32>,
   24     23   
    /// <p>Limits the response to keys that begin with the specified prefix.</p>
   25     24   
    pub prefix: ::std::option::Option<::std::string::String>,
   26     25   
    /// <p>Confirms that the requester knows that she or he will be charged for the list objects request. Bucket owners need not specify this parameter in their requests.</p>
   27     26   
    pub request_payer: ::std::option::Option<crate::types::RequestPayer>,
   28     27   
    /// <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>
   29     28   
    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,
   30     29   
    /// <p>Specifies the optional fields that you want returned in the response. Fields that you do not specify are not returned.</p>
   31     30   
    pub optional_object_attributes: ::std::option::Option<::std::vec::Vec<crate::types::OptionalObjectAttributes>>,
   32     31   
}
   33     32   
impl ListObjectsInput {
   34     33   
    /// <p>The name of the bucket containing the objects.</p>
   35     34   
    /// <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>
   36     35   
    /// <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>
   37     36   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   38     37   
    /// </note>
   39     38   
    /// <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>
   40     39   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   41     40   
        self.bucket.as_deref()
   42     41   
    }
   43     42   
    /// <p>A delimiter is a character that you use to group keys.</p>
   44         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
   45     43   
    pub fn delimiter(&self) -> ::std::option::Option<&str> {
   46     44   
        self.delimiter.as_deref()
   47     45   
    }
   48     46   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   49     47   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   50     48   
    /// </note>
   51     49   
    pub fn encoding_type(&self) -> ::std::option::Option<&crate::types::EncodingType> {
   52     50   
        self.encoding_type.as_ref()
   53     51   
    }
   54     52   
    /// <p>Marker is where you want Amazon S3 to start listing from. Amazon S3 starts listing after this specified key. Marker can be any key in the bucket.</p>
@@ -104,102 +176,171 @@
  124    122   
    /// <p>The name of the bucket containing the objects.</p>
  125    123   
    /// <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>
  126    124   
    /// <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>
  127    125   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  128    126   
    /// </note>
  129    127   
    /// <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>
  130    128   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  131    129   
        &self.bucket
  132    130   
    }
  133    131   
    /// <p>A delimiter is a character that you use to group keys.</p>
  134         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  135    132   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  136    133   
        self.delimiter = ::std::option::Option::Some(input.into());
  137    134   
        self
  138    135   
    }
  139    136   
    /// <p>A delimiter is a character that you use to group keys.</p>
  140         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  141    137   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  142    138   
        self.delimiter = input;
  143    139   
        self
  144    140   
    }
  145    141   
    /// <p>A delimiter is a character that you use to group keys.</p>
  146         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  147    142   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  148    143   
        &self.delimiter
  149    144   
    }
  150    145   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  151    146   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  152    147   
    /// </note>
  153    148   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  154    149   
        self.encoding_type = ::std::option::Option::Some(input);
  155    150   
        self
  156    151   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_objects/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.list_objects();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListObjects`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</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>Returns some or all (up to 1,000) of the objects in a bucket. You can use the request parameters as selection criteria to return a subset of the objects in a bucket. A 200 OK response can contain valid or invalid XML. Be sure to design your application to parse the contents of the response and handle it appropriately.</p><important>
   32     29   
/// <p>This action has been revised. We recommend that you use the newer version, <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html">ListObjectsV2</a>, when developing applications. For backward compatibility, Amazon S3 continues to support <code>ListObjects</code>.</p>
   33     30   
/// </important>
   34     31   
/// <p>The following operations are related to <code>ListObjects</code>:</p>
   35     32   
/// <ul>
   36     33   
/// <li>
   37     34   
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html">ListObjectsV2</a></p></li>
   38     35   
/// <li>
@@ -132,129 +204,198 @@
  152    149   
    /// <p>The name of the bucket containing the objects.</p>
  153    150   
    /// <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>
  154    151   
    /// <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>
  155    152   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  156    153   
    /// </note>
  157    154   
    /// <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>
  158    155   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  159    156   
        self.inner.get_bucket()
  160    157   
    }
  161    158   
    /// <p>A delimiter is a character that you use to group keys.</p>
  162         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  163    159   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  164    160   
        self.inner = self.inner.delimiter(input.into());
  165    161   
        self
  166    162   
    }
  167    163   
    /// <p>A delimiter is a character that you use to group keys.</p>
  168         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  169    164   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  170    165   
        self.inner = self.inner.set_delimiter(input);
  171    166   
        self
  172    167   
    }
  173    168   
    /// <p>A delimiter is a character that you use to group keys.</p>
  174         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the key-marker.</p>
  175    169   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  176    170   
        self.inner.get_delimiter()
  177    171   
    }
  178    172   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
  179    173   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
  180    174   
    /// </note>
  181    175   
    pub fn encoding_type(mut self, input: crate::types::EncodingType) -> Self {
  182    176   
        self.inner = self.inner.encoding_type(input);
  183    177   
        self
  184    178   
    }

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

@@ -1,1 +93,91 @@
    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 ListObjectsV2Input {
    6      6   
    /// <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>
    7      7   
    /// <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>
    8      8   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
    9      9   
    /// </note>
   10     10   
    /// <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>
   11     11   
    pub bucket: ::std::option::Option<::std::string::String>,
   12         -
    /// <p>A delimiter is a character that you use to group keys.</p>
   13         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
          12  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
   14     13   
    /// <ul>
   15     14   
    /// <li>
   16     15   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
   17     16   
    /// <li>
   18     17   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   19     18   
    /// </ul>
   20     19   
    /// </note>
   21     20   
    pub delimiter: ::std::option::Option<::std::string::String>,
   22     21   
    /// <p>Encoding type used by Amazon S3 to encode the <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html">object keys</a> in the response. Responses are encoded only in UTF-8. An object key can contain any Unicode character. However, the XML 1.0 parser can't parse certain characters, such as characters with an ASCII value from 0 to 10. For characters that aren't supported in XML 1.0, you can add this parameter to request that Amazon S3 encode the keys in the response. For more information about characters to avoid in object key names, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-guidelines">Object key naming guidelines</a>.</p><note>
   23     22   
    /// <p>When using the URL encoding type, non-ASCII characters that are used in an object's key name will be percent-encoded according to UTF-8 code values. For example, the object <code>test_file(3).png</code> will appear as <code>test_file%283%29.png</code>.</p>
   24     23   
    /// </note>
   25     24   
    pub encoding_type: ::std::option::Option<crate::types::EncodingType>,
   26     25   
    /// <p>Sets the maximum number of keys returned in the response. By default, the action returns up to 1,000 key names. The response might contain fewer keys but will never contain more.</p>
   27     26   
    pub max_keys: ::std::option::Option<i32>,
   28     27   
    /// <p>Limits the response to keys that begin with the specified prefix.</p><note>
   29     28   
    /// <p><b>Directory buckets</b> - For directory buckets, only prefixes that end in a delimiter (<code>/</code>) are supported.</p>
   30     29   
    /// </note>
   31     30   
    pub prefix: ::std::option::Option<::std::string::String>,
   32     31   
    /// <p><code>ContinuationToken</code> indicates to Amazon S3 that the list is being continued on this bucket with a token. <code>ContinuationToken</code> is obfuscated and is not a real key. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
   33     32   
    pub continuation_token: ::std::option::Option<::std::string::String>,
   34     33   
    /// <p>The owner field is not present in <code>ListObjectsV2</code> by default. If you want to return the owner field with each key in the result, then set the <code>FetchOwner</code> field to <code>true</code>.</p><note>
   35     34   
    /// <p><b>Directory buckets</b> - For directory buckets, the bucket owner is returned as the object owner for all objects.</p>
   36     35   
    /// </note>
   37     36   
    pub fetch_owner: ::std::option::Option<bool>,
   38     37   
    /// <p>StartAfter is where you want Amazon S3 to start listing from. Amazon S3 starts listing after this specified key. StartAfter can be any key in the bucket.</p><note>
   39     38   
    /// <p>This functionality is not supported for directory buckets.</p>
   40     39   
    /// </note>
   41     40   
    pub start_after: ::std::option::Option<::std::string::String>,
   42     41   
    /// <p>Confirms that the requester knows that she or he will be charged for the list objects request in V2 style. Bucket owners need not specify this parameter in their requests.</p><note>
   43     42   
    /// <p>This functionality is not supported for directory buckets.</p>
   44     43   
    /// </note>
   45     44   
    pub request_payer: ::std::option::Option<crate::types::RequestPayer>,
   46     45   
    /// <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>
   47     46   
    pub expected_bucket_owner: ::std::option::Option<::std::string::String>,
   48     47   
    /// <p>Specifies the optional fields that you want returned in the response. Fields that you do not specify are not returned.</p><note>
   49     48   
    /// <p>This functionality is not supported for directory buckets.</p>
   50     49   
    /// </note>
   51     50   
    pub optional_object_attributes: ::std::option::Option<::std::vec::Vec<crate::types::OptionalObjectAttributes>>,
   52     51   
}
   53     52   
impl ListObjectsV2Input {
   54     53   
    /// <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>
   55     54   
    /// <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>
   56     55   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
   57     56   
    /// </note>
   58     57   
    /// <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>
   59     58   
    pub fn bucket(&self) -> ::std::option::Option<&str> {
   60     59   
        self.bucket.as_deref()
   61     60   
    }
   62         -
    /// <p>A delimiter is a character that you use to group keys.</p>
   63         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
          61  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
   64     62   
    /// <ul>
   65     63   
    /// <li>
   66     64   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
   67     65   
    /// <li>
   68     66   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   69     67   
    /// </ul>
   70     68   
    /// </note>
   71     69   
    pub fn delimiter(&self) -> ::std::option::Option<&str> {
   72     70   
        self.delimiter.as_deref()
   73     71   
    }
@@ -146,144 +233,228 @@
  166    164   
        self
  167    165   
    }
  168    166   
    /// <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>
  169    167   
    /// <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>
  170    168   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  171    169   
    /// </note>
  172    170   
    /// <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>
  173    171   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  174    172   
        &self.bucket
  175    173   
    }
  176         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  177         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         174  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  178    175   
    /// <ul>
  179    176   
    /// <li>
  180    177   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  181    178   
    /// <li>
  182    179   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  183    180   
    /// </ul>
  184    181   
    /// </note>
  185    182   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  186    183   
        self.delimiter = ::std::option::Option::Some(input.into());
  187    184   
        self
  188    185   
    }
  189         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  190         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         186  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  191    187   
    /// <ul>
  192    188   
    /// <li>
  193    189   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  194    190   
    /// <li>
  195    191   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  196    192   
    /// </ul>
  197    193   
    /// </note>
  198    194   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  199    195   
        self.delimiter = input;
  200    196   
        self
  201    197   
    }
  202         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  203         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         198  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  204    199   
    /// <ul>
  205    200   
    /// <li>
  206    201   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  207    202   
    /// <li>
  208    203   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  209    204   
    /// </ul>
  210    205   
    /// </note>
  211    206   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  212    207   
        &self.delimiter
  213    208   
    }

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

@@ -11,11 +71,71 @@
   31     31   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
   32     32   
    /// </ul>
   33     33   
    /// </note>
   34     34   
    pub common_prefixes: ::std::option::Option<::std::vec::Vec<crate::types::CommonPrefix>>,
   35     35   
    /// <p>Encoding type used by Amazon S3 to encode object key names in the XML response.</p>
   36     36   
    /// <p>If you specify the <code>encoding-type</code> request parameter, Amazon S3 includes this element in the response, and returns encoded key name values in the following response elements:</p>
   37     37   
    /// <p><code>Delimiter, Prefix, Key,</code> and <code>StartAfter</code>.</p>
   38     38   
    pub encoding_type: ::std::option::Option<crate::types::EncodingType>,
   39     39   
    /// <p><code>KeyCount</code> is the number of keys returned with this request. <code>KeyCount</code> will always be less than or equal to the <code>MaxKeys</code> field. For example, if you ask for 50 keys, your result will include 50 keys or fewer.</p>
   40     40   
    pub key_count: ::std::option::Option<i32>,
   41         -
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response.</p>
          41  +
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
   42     42   
    pub continuation_token: ::std::option::Option<::std::string::String>,
   43     43   
    /// <p><code>NextContinuationToken</code> is sent when <code>isTruncated</code> is true, which means there are more keys in the bucket that can be listed. The next list requests to Amazon S3 can be continued with this <code>NextContinuationToken</code>. <code>NextContinuationToken</code> is obfuscated and is not a real key</p>
   44     44   
    pub next_continuation_token: ::std::option::Option<::std::string::String>,
   45     45   
    /// <p>If StartAfter was sent with the request, it is included in the response.</p><note>
   46     46   
    /// <p>This functionality is not supported for directory buckets.</p>
   47     47   
    /// </note>
   48     48   
    pub start_after: ::std::option::Option<::std::string::String>,
   49     49   
    /// <p>If present, indicates that the requester was successfully charged for the request. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/RequesterPaysBuckets.html">Using Requester Pays buckets for storage transfers and usage</a> in the <i>Amazon Simple Storage Service user guide</i>.</p><note>
   50     50   
    /// <p>This functionality is not supported for directory buckets.</p>
   51     51   
    /// </note>
@@ -84,84 +144,144 @@
  104    104   
    /// <p>Encoding type used by Amazon S3 to encode object key names in the XML response.</p>
  105    105   
    /// <p>If you specify the <code>encoding-type</code> request parameter, Amazon S3 includes this element in the response, and returns encoded key name values in the following response elements:</p>
  106    106   
    /// <p><code>Delimiter, Prefix, Key,</code> and <code>StartAfter</code>.</p>
  107    107   
    pub fn encoding_type(&self) -> ::std::option::Option<&crate::types::EncodingType> {
  108    108   
        self.encoding_type.as_ref()
  109    109   
    }
  110    110   
    /// <p><code>KeyCount</code> is the number of keys returned with this request. <code>KeyCount</code> will always be less than or equal to the <code>MaxKeys</code> field. For example, if you ask for 50 keys, your result will include 50 keys or fewer.</p>
  111    111   
    pub fn key_count(&self) -> ::std::option::Option<i32> {
  112    112   
        self.key_count
  113    113   
    }
  114         -
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response.</p>
         114  +
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
  115    115   
    pub fn continuation_token(&self) -> ::std::option::Option<&str> {
  116    116   
        self.continuation_token.as_deref()
  117    117   
    }
  118    118   
    /// <p><code>NextContinuationToken</code> is sent when <code>isTruncated</code> is true, which means there are more keys in the bucket that can be listed. The next list requests to Amazon S3 can be continued with this <code>NextContinuationToken</code>. <code>NextContinuationToken</code> is obfuscated and is not a real key</p>
  119    119   
    pub fn next_continuation_token(&self) -> ::std::option::Option<&str> {
  120    120   
        self.next_continuation_token.as_deref()
  121    121   
    }
  122    122   
    /// <p>If StartAfter was sent with the request, it is included in the response.</p><note>
  123    123   
    /// <p>This functionality is not supported for directory buckets.</p>
  124    124   
    /// </note>
@@ -332,332 +402,402 @@
  352    352   
    }
  353    353   
    /// <p><code>KeyCount</code> is the number of keys returned with this request. <code>KeyCount</code> will always be less than or equal to the <code>MaxKeys</code> field. For example, if you ask for 50 keys, your result will include 50 keys or fewer.</p>
  354    354   
    pub fn set_key_count(mut self, input: ::std::option::Option<i32>) -> Self {
  355    355   
        self.key_count = input;
  356    356   
        self
  357    357   
    }
  358    358   
    /// <p><code>KeyCount</code> is the number of keys returned with this request. <code>KeyCount</code> will always be less than or equal to the <code>MaxKeys</code> field. For example, if you ask for 50 keys, your result will include 50 keys or fewer.</p>
  359    359   
    pub fn get_key_count(&self) -> &::std::option::Option<i32> {
  360    360   
        &self.key_count
  361    361   
    }
  362         -
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response.</p>
         362  +
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
  363    363   
    pub fn continuation_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  364    364   
        self.continuation_token = ::std::option::Option::Some(input.into());
  365    365   
        self
  366    366   
    }
  367         -
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response.</p>
         367  +
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
  368    368   
    pub fn set_continuation_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  369    369   
        self.continuation_token = input;
  370    370   
        self
  371    371   
    }
  372         -
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response.</p>
         372  +
    /// <p>If <code>ContinuationToken</code> was sent with the request, it is included in the response. You can use the returned <code>ContinuationToken</code> for pagination of the list response. You can use this <code>ContinuationToken</code> for pagination of the list results.</p>
  373    373   
    pub fn get_continuation_token(&self) -> &::std::option::Option<::std::string::String> {
  374    374   
        &self.continuation_token
  375    375   
    }
  376    376   
    /// <p><code>NextContinuationToken</code> is sent when <code>isTruncated</code> is true, which means there are more keys in the bucket that can be listed. The next list requests to Amazon S3 can be continued with this <code>NextContinuationToken</code>. <code>NextContinuationToken</code> is obfuscated and is not a real key</p>
  377    377   
    pub fn next_continuation_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  378    378   
        self.next_continuation_token = ::std::option::Option::Some(input.into());
  379    379   
        self
  380    380   
    }
  381    381   
    /// <p><code>NextContinuationToken</code> is sent when <code>isTruncated</code> is true, which means there are more keys in the bucket that can be listed. The next list requests to Amazon S3 can be continued with this <code>NextContinuationToken</code>. <code>NextContinuationToken</code> is obfuscated and is not a real key</p>
  382    382   
    pub fn set_next_continuation_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

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

@@ -163,163 +250,247 @@
  183    183   
        self
  184    184   
    }
  185    185   
    /// <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>
  186    186   
    /// <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>
  187    187   
    /// <p>Object Lambda access points are not supported by directory buckets.</p>
  188    188   
    /// </note>
  189    189   
    /// <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>
  190    190   
    pub fn get_bucket(&self) -> &::std::option::Option<::std::string::String> {
  191    191   
        self.inner.get_bucket()
  192    192   
    }
  193         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  194         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         193  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  195    194   
    /// <ul>
  196    195   
    /// <li>
  197    196   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  198    197   
    /// <li>
  199    198   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  200    199   
    /// </ul>
  201    200   
    /// </note>
  202    201   
    pub fn delimiter(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  203    202   
        self.inner = self.inner.delimiter(input.into());
  204    203   
        self
  205    204   
    }
  206         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  207         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         205  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  208    206   
    /// <ul>
  209    207   
    /// <li>
  210    208   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  211    209   
    /// <li>
  212    210   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  213    211   
    /// </ul>
  214    212   
    /// </note>
  215    213   
    pub fn set_delimiter(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  216    214   
        self.inner = self.inner.set_delimiter(input);
  217    215   
        self
  218    216   
    }
  219         -
    /// <p>A delimiter is a character that you use to group keys.</p>
  220         -
    /// <p><code>CommonPrefixes</code> is filtered out from results if it is not lexicographically greater than the <code>StartAfter</code> value.</p><note>
         217  +
    /// <p>A delimiter is a character that you use to group keys.</p><note>
  221    218   
    /// <ul>
  222    219   
    /// <li>
  223    220   
    /// <p><b>Directory buckets</b> - For directory buckets, <code>/</code> is the only supported delimiter.</p></li>
  224    221   
    /// <li>
  225    222   
    /// <p><b>Directory buckets </b> - When you query <code>ListObjectsV2</code> with a delimiter during in-progress multipart uploads, the <code>CommonPrefixes</code> response parameter contains the prefixes that are associated with the in-progress multipart uploads. For more information about multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html">Multipart Upload Overview</a> in the <i>Amazon S3 User Guide</i>.</p></li>
  226    223   
    /// </ul>
  227    224   
    /// </note>
  228    225   
    pub fn get_delimiter(&self) -> &::std::option::Option<::std::string::String> {
  229    226   
        self.inner.get_delimiter()
  230    227   
    }

tmp-codegen-diff/aws-sdk/sdk/s3/src/operation/list_parts/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.list_parts();
   19     19   
        fluent_builder.inner = self;
   20     20   
        fluent_builder.send().await
   21     21   
    }
   22     22   
}
   23     23   
/// Fluent builder constructing a request to `ListParts`.
   24     24   
///
   25         -
/// <important>
   26         -
/// <p>End of support notice: Beginning October 1, 2025, Amazon S3 will stop returning <code>DisplayName</code>. Update your applications to use canonical IDs (unique identifier for Amazon Web Services accounts), Amazon Web Services account ID (12 digit identifier) or IAM ARNs (full resource naming) as a direct replacement of <code>DisplayName</code>.</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>Lists the parts that have been uploaded for a specific multipart upload.</p>
   30     26   
/// <p>To use this operation, you must provide the <code>upload ID</code> in the request. You obtain this uploadID by sending the initiate multipart upload request through <a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateMultipartUpload.html">CreateMultipartUpload</a>.</p>
   31     27   
/// <p>The <code>ListParts</code> request returns a maximum of 1,000 uploaded parts. The limit of 1,000 parts is also the default value. You can restrict the number of parts in a response by specifying the <code>max-parts</code> request parameter. If your multipart upload consists of more than 1,000 parts, the response returns an <code>IsTruncated</code> field with the value of <code>true</code>, and a <code>NextPartNumberMarker</code> element. To list remaining uploaded parts, in subsequent <code>ListParts</code> requests, include the <code>part-number-marker</code> query string parameter and set its value to the <code>NextPartNumberMarker</code> field value from the previous response.</p>
   32     28   
/// <p>For more information on multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/uploadobjusingmpu.html">Uploading Objects Using Multipart Upload</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   33     29   
/// <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>
   34     30   
/// </note>
   35     31   
/// <dl>
   36     32   
/// <dt>
   37     33   
/// Permissions
   38     34   
/// </dt>