AWS SDK

AWS SDK

rev. c26d7058724dd0bfafdd4903fbdfb18b373ab965

Files changed:

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

@@ -1,1 +57,71 @@
    6      6   
    #[allow(unused_mut)]
    7      7   
    let mut scope = writer.finish();
    8      8   
    if let Some(var_1) = &input.apply_server_side_encryption_by_default {
    9      9   
        let inner_writer = scope.start_el("ApplyServerSideEncryptionByDefault");
   10     10   
        crate::protocol_serde::shape_server_side_encryption_by_default::ser_server_side_encryption_by_default(var_1, inner_writer)?
   11     11   
    }
   12     12   
    if let Some(var_2) = &input.bucket_key_enabled {
   13     13   
        let mut inner_writer = scope.start_el("BucketKeyEnabled").finish();
   14     14   
        inner_writer.data(::aws_smithy_types::primitive::Encoder::from(*var_2).encode());
   15     15   
    }
          16  +
    if let Some(var_3) = &input.blocked_encryption_types {
          17  +
        let inner_writer = scope.start_el("BlockedEncryptionTypes");
          18  +
        crate::protocol_serde::shape_blocked_encryption_types::ser_blocked_encryption_types(var_3, inner_writer)?
          19  +
    }
   16     20   
    scope.finish();
   17     21   
    Ok(())
   18     22   
}
   19     23   
   20     24   
#[allow(clippy::needless_question_mark)]
   21     25   
pub fn de_server_side_encryption_rule(
   22     26   
    decoder: &mut ::aws_smithy_xml::decode::ScopedDecoder,
   23     27   
) -> ::std::result::Result<crate::types::ServerSideEncryptionRule, ::aws_smithy_xml::decode::XmlDecodeError> {
   24     28   
    #[allow(unused_mut)]
   25     29   
    let mut builder = crate::types::ServerSideEncryptionRule::builder();
   26     30   
    while let Some(mut tag) = decoder.next_tag() {
   27     31   
        match tag.start_el() {
   28     32   
            s if s.matches("ApplyServerSideEncryptionByDefault") /* ApplyServerSideEncryptionByDefault com.amazonaws.s3#ServerSideEncryptionRule$ApplyServerSideEncryptionByDefault */ =>  {
   29         -
                let var_3 =
          33  +
                let var_4 =
   30     34   
                    Some(
   31     35   
                        crate::protocol_serde::shape_server_side_encryption_by_default::de_server_side_encryption_by_default(&mut tag)
   32     36   
                        ?
   33     37   
                    )
   34     38   
                ;
   35         -
                builder = builder.set_apply_server_side_encryption_by_default(var_3);
          39  +
                builder = builder.set_apply_server_side_encryption_by_default(var_4);
   36     40   
            }
   37     41   
            ,
   38     42   
            s if s.matches("BucketKeyEnabled") /* BucketKeyEnabled com.amazonaws.s3#ServerSideEncryptionRule$BucketKeyEnabled */ =>  {
   39         -
                let var_4 =
          43  +
                let var_5 =
   40     44   
                    Some(
   41     45   
                         {
   42     46   
                            <bool as ::aws_smithy_types::primitive::Parse>::parse_smithy_primitive(
   43     47   
                                ::aws_smithy_xml::decode::try_data(&mut tag)?.as_ref()
   44     48   
                            )
   45     49   
                            .map_err(|_|::aws_smithy_xml::decode::XmlDecodeError::custom("expected (boolean: `com.amazonaws.s3#BucketKeyEnabled`)"))
   46     50   
                        }
   47     51   
                        ?
   48     52   
                    )
   49     53   
                ;
   50         -
                builder = builder.set_bucket_key_enabled(var_4);
          54  +
                builder = builder.set_bucket_key_enabled(var_5);
          55  +
            }
          56  +
            ,
          57  +
            s if s.matches("BlockedEncryptionTypes") /* BlockedEncryptionTypes com.amazonaws.s3#ServerSideEncryptionRule$BlockedEncryptionTypes */ =>  {
          58  +
                let var_6 =
          59  +
                    Some(
          60  +
                        crate::protocol_serde::shape_blocked_encryption_types::de_blocked_encryption_types(&mut tag)
          61  +
                        ?
          62  +
                    )
          63  +
                ;
          64  +
                builder = builder.set_blocked_encryption_types(var_6);
   51     65   
            }
   52     66   
            ,
   53     67   
            _ => {}
   54     68   
        }
   55     69   
    }
   56     70   
    Ok(builder.build())
   57     71   
}

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

@@ -14,14 +73,75 @@
   34     34   
pub use crate::types::_metadata_configuration::MetadataConfiguration;
   35     35   
   36     36   
pub use crate::types::_metadata_table_configuration::MetadataTableConfiguration;
   37     37   
   38     38   
pub use crate::types::_session_mode::SessionMode;
   39     39   
   40     40   
pub use crate::types::_session_credentials::SessionCredentials;
   41     41   
   42     42   
pub use crate::types::_delete::Delete;
   43     43   
          44  +
pub use crate::types::_abac_status::AbacStatus;
          45  +
   44     46   
pub use crate::types::_bucket_accelerate_status::BucketAccelerateStatus;
   45     47   
   46     48   
pub use crate::types::_owner::Owner;
   47     49   
   48     50   
pub use crate::types::_analytics_configuration::AnalyticsConfiguration;
   49     51   
   50     52   
pub use crate::types::_server_side_encryption_configuration::ServerSideEncryptionConfiguration;
   51     53   
   52     54   
pub use crate::types::_intelligent_tiering_configuration::IntelligentTieringConfiguration;
   53     55   
@@ -138,140 +197,201 @@
  158    160   
pub use crate::types::_journal_table_configuration::JournalTableConfiguration;
  159    161   
  160    162   
pub use crate::types::_inventory_table_configuration::InventoryTableConfiguration;
  161    163   
  162    164   
pub use crate::types::_s3_tables_destination::S3TablesDestination;
  163    165   
  164    166   
pub use crate::types::_deleted_object::DeletedObject;
  165    167   
  166    168   
pub use crate::types::_error::Error;
  167    169   
         170  +
pub use crate::types::_bucket_abac_status::BucketAbacStatus;
         171  +
  168    172   
pub use crate::types::_grant::Grant;
  169    173   
  170    174   
pub use crate::types::_analytics_filter::AnalyticsFilter;
  171    175   
  172    176   
pub use crate::types::_storage_class_analysis::StorageClassAnalysis;
  173    177   
  174    178   
pub use crate::types::_cors_rule::CorsRule;
  175    179   
  176    180   
pub use crate::types::_intelligent_tiering_filter::IntelligentTieringFilter;
  177    181   
@@ -344,348 +403,409 @@
  364    368   
pub use crate::types::_expiration_state::ExpirationState;
  365    369   
  366    370   
pub use crate::types::_type_::Type;
  367    371   
  368    372   
pub use crate::types::_storage_class_analysis_schema_version::StorageClassAnalysisSchemaVersion;
  369    373   
  370    374   
pub use crate::types::_analytics_export_destination::AnalyticsExportDestination;
  371    375   
  372    376   
pub use crate::types::_server_side_encryption_by_default::ServerSideEncryptionByDefault;
  373    377   
         378  +
pub use crate::types::_blocked_encryption_types::BlockedEncryptionTypes;
         379  +
  374    380   
pub use crate::types::_inventory_format::InventoryFormat;
  375    381   
  376    382   
pub use crate::types::_inventory_encryption::InventoryEncryption;
  377    383   
  378    384   
pub use crate::types::_lifecycle_rule_and_operator::LifecycleRuleAndOperator;
  379    385   
  380    386   
pub use crate::types::_transition::Transition;
  381    387   
  382    388   
pub use crate::types::_noncurrent_version_transition::NoncurrentVersionTransition;
  383    389   
@@ -408,414 +507,521 @@
  428    434   
pub use crate::types::_replication_time::ReplicationTime;
  429    435   
  430    436   
pub use crate::types::_metrics::Metrics;
  431    437   
  432    438   
pub use crate::types::_delete_marker_replication_status::DeleteMarkerReplicationStatus;
  433    439   
  434    440   
pub use crate::types::_metadata_entry::MetadataEntry;
  435    441   
  436    442   
pub use crate::types::_analytics_s3_export_file_format::AnalyticsS3ExportFileFormat;
  437    443   
         444  +
pub use crate::types::_encryption_type::EncryptionType;
         445  +
  438    446   
pub use crate::types::_filter_rule::FilterRule;
  439    447   
  440    448   
pub use crate::types::_sse_kms_encrypted_objects_status::SseKmsEncryptedObjectsStatus;
  441    449   
  442    450   
pub use crate::types::_replica_modifications_status::ReplicaModificationsStatus;
  443    451   
  444    452   
pub use crate::types::_owner_override::OwnerOverride;
  445    453   
  446    454   
pub use crate::types::_replication_time_status::ReplicationTimeStatus;
  447    455   
  448    456   
pub use crate::types::_replication_time_value::ReplicationTimeValue;
  449    457   
  450    458   
pub use crate::types::_metrics_status::MetricsStatus;
  451    459   
  452    460   
pub use crate::types::_filter_rule_name::FilterRuleName;
  453    461   
         462  +
mod _abac_status;
         463  +
  454    464   
mod _abort_incomplete_multipart_upload;
  455    465   
  456    466   
mod _accelerate_configuration;
  457    467   
  458    468   
mod _access_control_policy;
  459    469   
  460    470   
mod _access_control_translation;
  461    471   
  462    472   
mod _analytics_and_operator;
  463    473   
  464    474   
mod _analytics_configuration;
  465    475   
  466    476   
mod _analytics_export_destination;
  467    477   
  468    478   
mod _analytics_filter;
  469    479   
  470    480   
mod _analytics_s3_bucket_destination;
  471    481   
  472    482   
mod _analytics_s3_export_file_format;
  473    483   
  474    484   
mod _archive_status;
  475    485   
         486  +
mod _blocked_encryption_types;
         487  +
  476    488   
mod _bucket;
  477    489   
         490  +
mod _bucket_abac_status;
         491  +
  478    492   
mod _bucket_accelerate_status;
  479    493   
  480    494   
mod _bucket_canned_acl;
  481    495   
  482    496   
mod _bucket_info;
  483    497   
  484    498   
mod _bucket_lifecycle_configuration;
  485    499   
  486    500   
mod _bucket_location_constraint;
  487    501   
@@ -524,538 +583,599 @@
  544    558   
mod _destination;
  545    559   
  546    560   
mod _destination_result;
  547    561   
  548    562   
mod _encoding_type;
  549    563   
  550    564   
mod _encryption;
  551    565   
  552    566   
mod _encryption_configuration;
  553    567   
         568  +
mod _encryption_type;
         569  +
  554    570   
mod _end_event;
  555    571   
  556    572   
mod _error;
  557    573   
  558    574   
mod _error_details;
  559    575   
  560    576   
mod _error_document;
  561    577   
  562    578   
mod _event;
  563    579   

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

@@ -0,1 +0,48 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>The ABAC status of the general purpose bucket. When ABAC is enabled for the general purpose bucket, you can use tags to manage access to the general purpose buckets as well as for cost tracking purposes. When ABAC is disabled for the general purpose buckets, you can only use tags for cost tracking purposes. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging.html">Using tags with S3 general purpose buckets</a>.</p>
           4  +
#[non_exhaustive]
           5  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           6  +
pub struct AbacStatus {
           7  +
    /// <p>The ABAC status of the general purpose bucket.</p>
           8  +
    pub status: ::std::option::Option<crate::types::BucketAbacStatus>,
           9  +
}
          10  +
impl AbacStatus {
          11  +
    /// <p>The ABAC status of the general purpose bucket.</p>
          12  +
    pub fn status(&self) -> ::std::option::Option<&crate::types::BucketAbacStatus> {
          13  +
        self.status.as_ref()
          14  +
    }
          15  +
}
          16  +
impl AbacStatus {
          17  +
    /// Creates a new builder-style object to manufacture [`AbacStatus`](crate::types::AbacStatus).
          18  +
    pub fn builder() -> crate::types::builders::AbacStatusBuilder {
          19  +
        crate::types::builders::AbacStatusBuilder::default()
          20  +
    }
          21  +
}
          22  +
          23  +
/// A builder for [`AbacStatus`](crate::types::AbacStatus).
          24  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
          25  +
#[non_exhaustive]
          26  +
pub struct AbacStatusBuilder {
          27  +
    pub(crate) status: ::std::option::Option<crate::types::BucketAbacStatus>,
          28  +
}
          29  +
impl AbacStatusBuilder {
          30  +
    /// <p>The ABAC status of the general purpose bucket.</p>
          31  +
    pub fn status(mut self, input: crate::types::BucketAbacStatus) -> Self {
          32  +
        self.status = ::std::option::Option::Some(input);
          33  +
        self
          34  +
    }
          35  +
    /// <p>The ABAC status of the general purpose bucket.</p>
          36  +
    pub fn set_status(mut self, input: ::std::option::Option<crate::types::BucketAbacStatus>) -> Self {
          37  +
        self.status = input;
          38  +
        self
          39  +
    }
          40  +
    /// <p>The ABAC status of the general purpose bucket.</p>
          41  +
    pub fn get_status(&self) -> &::std::option::Option<crate::types::BucketAbacStatus> {
          42  +
        &self.status
          43  +
    }
          44  +
    /// Consumes the builder and constructs a [`AbacStatus`](crate::types::AbacStatus).
          45  +
    pub fn build(self) -> crate::types::AbacStatus {
          46  +
        crate::types::AbacStatus { status: self.status }
          47  +
    }
          48  +
}

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

@@ -0,1 +0,86 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// <p>A bucket-level setting for Amazon S3 general purpose buckets used to prevent the upload of new objects encrypted with the specified server-side encryption type. For example, blocking an encryption type will block <code>PutObject</code>, <code>CopyObject</code>, <code>PostObject</code>, multipart upload, and replication requests to the bucket for objects with the specified encryption type. However, you can continue to read and list any pre-existing objects already encrypted with the specified encryption type. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/blocking-unblocking-s3-c-encryption-gpb.html">Blocking or unblocking SSE-C for a general purpose bucket</a>.</p>
           4  +
/// <p>This data type is used with the following actions:</p>
           5  +
/// <ul>
           6  +
/// <li>
           7  +
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketEncryption.html">PutBucketEncryption</a></p></li>
           8  +
/// <li>
           9  +
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketEncryption.html">GetBucketEncryption</a></p></li>
          10  +
/// <li>
          11  +
/// <p><a href="https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketEncryption.html">DeleteBucketEncryption</a></p></li>
          12  +
/// </ul>
          13  +
/// <dl>
          14  +
/// <dt>
          15  +
/// Permissions
          16  +
/// </dt>
          17  +
/// <dd>
          18  +
/// <p>You must have the <code>s3:PutEncryptionConfiguration</code> permission to block or unblock an encryption type for a bucket.</p>
          19  +
/// <p>You must have the <code>s3:GetEncryptionConfiguration</code> permission to view a bucket's encryption type.</p>
          20  +
/// </dd>
          21  +
/// </dl>
          22  +
#[non_exhaustive]
          23  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
          24  +
pub struct BlockedEncryptionTypes {
          25  +
    /// <p>The object encryption type that you want to block or unblock for an Amazon S3 general purpose bucket.</p><note>
          26  +
    /// <p>Currently, this parameter only supports blocking or unblocking server side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          27  +
    /// </note>
          28  +
    pub encryption_type: ::std::option::Option<::std::vec::Vec<crate::types::EncryptionType>>,
          29  +
}
          30  +
impl BlockedEncryptionTypes {
          31  +
    /// <p>The object encryption type that you want to block or unblock for an Amazon S3 general purpose bucket.</p><note>
          32  +
    /// <p>Currently, this parameter only supports blocking or unblocking server side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          33  +
    /// </note>
          34  +
    ///
          35  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.encryption_type.is_none()`.
          36  +
    pub fn encryption_type(&self) -> &[crate::types::EncryptionType] {
          37  +
        self.encryption_type.as_deref().unwrap_or_default()
          38  +
    }
          39  +
}
          40  +
impl BlockedEncryptionTypes {
          41  +
    /// Creates a new builder-style object to manufacture [`BlockedEncryptionTypes`](crate::types::BlockedEncryptionTypes).
          42  +
    pub fn builder() -> crate::types::builders::BlockedEncryptionTypesBuilder {
          43  +
        crate::types::builders::BlockedEncryptionTypesBuilder::default()
          44  +
    }
          45  +
}
          46  +
          47  +
/// A builder for [`BlockedEncryptionTypes`](crate::types::BlockedEncryptionTypes).
          48  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
          49  +
#[non_exhaustive]
          50  +
pub struct BlockedEncryptionTypesBuilder {
          51  +
    pub(crate) encryption_type: ::std::option::Option<::std::vec::Vec<crate::types::EncryptionType>>,
          52  +
}
          53  +
impl BlockedEncryptionTypesBuilder {
          54  +
    /// Appends an item to `encryption_type`.
          55  +
    ///
          56  +
    /// To override the contents of this collection use [`set_encryption_type`](Self::set_encryption_type).
          57  +
    ///
          58  +
    /// <p>The object encryption type that you want to block or unblock for an Amazon S3 general purpose bucket.</p><note>
          59  +
    /// <p>Currently, this parameter only supports blocking or unblocking server side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          60  +
    /// </note>
          61  +
    pub fn encryption_type(mut self, input: crate::types::EncryptionType) -> Self {
          62  +
        let mut v = self.encryption_type.unwrap_or_default();
          63  +
        v.push(input);
          64  +
        self.encryption_type = ::std::option::Option::Some(v);
          65  +
        self
          66  +
    }
          67  +
    /// <p>The object encryption type that you want to block or unblock for an Amazon S3 general purpose bucket.</p><note>
          68  +
    /// <p>Currently, this parameter only supports blocking or unblocking server side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          69  +
    /// </note>
          70  +
    pub fn set_encryption_type(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::EncryptionType>>) -> Self {
          71  +
        self.encryption_type = input;
          72  +
        self
          73  +
    }
          74  +
    /// <p>The object encryption type that you want to block or unblock for an Amazon S3 general purpose bucket.</p><note>
          75  +
    /// <p>Currently, this parameter only supports blocking or unblocking server side encryption with customer-provided keys (SSE-C). For more information about SSE-C, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html">Using server-side encryption with customer-provided keys (SSE-C)</a>.</p>
          76  +
    /// </note>
          77  +
    pub fn get_encryption_type(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::EncryptionType>> {
          78  +
        &self.encryption_type
          79  +
    }
          80  +
    /// Consumes the builder and constructs a [`BlockedEncryptionTypes`](crate::types::BlockedEncryptionTypes).
          81  +
    pub fn build(self) -> crate::types::BlockedEncryptionTypes {
          82  +
        crate::types::BlockedEncryptionTypes {
          83  +
            encryption_type: self.encryption_type,
          84  +
        }
          85  +
    }
          86  +
}

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

@@ -0,1 +0,108 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// When writing a match expression against `BucketAbacStatus`, it is important to ensure
           4  +
/// your code is forward-compatible. That is, if a match arm handles a case for a
           5  +
/// feature that is supported by the service but has not been represented as an enum
           6  +
/// variant in a current version of SDK, your code should continue to work when you
           7  +
/// upgrade SDK to a future version in which the enum does include a variant for that
           8  +
/// feature.
           9  +
///
          10  +
/// Here is an example of how you can make a match expression forward-compatible:
          11  +
///
          12  +
/// ```text
          13  +
/// # let bucketabacstatus = unimplemented!();
          14  +
/// match bucketabacstatus {
          15  +
///     BucketAbacStatus::Disabled => { /* ... */ },
          16  +
///     BucketAbacStatus::Enabled => { /* ... */ },
          17  +
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          18  +
///     _ => { /* ... */ },
          19  +
/// }
          20  +
/// ```
          21  +
/// The above code demonstrates that when `bucketabacstatus` represents
          22  +
/// `NewFeature`, the execution path will lead to the second last match arm,
          23  +
/// even though the enum does not contain a variant `BucketAbacStatus::NewFeature`
          24  +
/// in the current version of SDK. The reason is that the variable `other`,
          25  +
/// created by the `@` operator, is bound to
          26  +
/// `BucketAbacStatus::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
          27  +
/// and calling `as_str` on it yields `"NewFeature"`.
          28  +
/// This match expression is forward-compatible when executed with a newer
          29  +
/// version of SDK where the variant `BucketAbacStatus::NewFeature` is defined.
          30  +
/// Specifically, when `bucketabacstatus` represents `NewFeature`,
          31  +
/// the execution path will hit the second last match arm as before by virtue of
          32  +
/// calling `as_str` on `BucketAbacStatus::NewFeature` also yielding `"NewFeature"`.
          33  +
///
          34  +
/// Explicitly matching on the `Unknown` variant should
          35  +
/// be avoided for two reasons:
          36  +
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
          37  +
/// - It might inadvertently shadow other intended match arms.
          38  +
///
          39  +
#[allow(missing_docs)] // documentation missing in model
          40  +
#[non_exhaustive]
          41  +
#[derive(
          42  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
          43  +
)]
          44  +
pub enum BucketAbacStatus {
          45  +
    #[allow(missing_docs)] // documentation missing in model
          46  +
    Disabled,
          47  +
    #[allow(missing_docs)] // documentation missing in model
          48  +
    Enabled,
          49  +
    /// `Unknown` contains new variants that have been added since this code was generated.
          50  +
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
          51  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          52  +
}
          53  +
impl ::std::convert::From<&str> for BucketAbacStatus {
          54  +
    fn from(s: &str) -> Self {
          55  +
        match s {
          56  +
            "Disabled" => BucketAbacStatus::Disabled,
          57  +
            "Enabled" => BucketAbacStatus::Enabled,
          58  +
            other => BucketAbacStatus::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
          59  +
        }
          60  +
    }
          61  +
}
          62  +
impl ::std::str::FromStr for BucketAbacStatus {
          63  +
    type Err = ::std::convert::Infallible;
          64  +
          65  +
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
          66  +
        ::std::result::Result::Ok(BucketAbacStatus::from(s))
          67  +
    }
          68  +
}
          69  +
impl BucketAbacStatus {
          70  +
    /// Returns the `&str` value of the enum member.
          71  +
    pub fn as_str(&self) -> &str {
          72  +
        match self {
          73  +
            BucketAbacStatus::Disabled => "Disabled",
          74  +
            BucketAbacStatus::Enabled => "Enabled",
          75  +
            BucketAbacStatus::Unknown(value) => value.as_str(),
          76  +
        }
          77  +
    }
          78  +
    /// Returns all the `&str` representations of the enum members.
          79  +
    pub const fn values() -> &'static [&'static str] {
          80  +
        &["Disabled", "Enabled"]
          81  +
    }
          82  +
}
          83  +
impl ::std::convert::AsRef<str> for BucketAbacStatus {
          84  +
    fn as_ref(&self) -> &str {
          85  +
        self.as_str()
          86  +
    }
          87  +
}
          88  +
impl BucketAbacStatus {
          89  +
    /// Parses the enum value while disallowing unknown variants.
          90  +
    ///
          91  +
    /// Unknown variants will result in an error.
          92  +
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
          93  +
        match Self::from(value) {
          94  +
            #[allow(deprecated)]
          95  +
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
          96  +
            known => Ok(known),
          97  +
        }
          98  +
    }
          99  +
}
         100  +
impl ::std::fmt::Display for BucketAbacStatus {
         101  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         102  +
        match self {
         103  +
            BucketAbacStatus::Disabled => write!(f, "Disabled"),
         104  +
            BucketAbacStatus::Enabled => write!(f, "Enabled"),
         105  +
            BucketAbacStatus::Unknown(value) => write!(f, "{value}"),
         106  +
        }
         107  +
    }
         108  +
}

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

@@ -1,1 +160,160 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3      3   
/// <p>Contains all the possible checksum or digest values for an object.</p>
    4      4   
#[non_exhaustive]
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct Checksum {
    7         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
           7  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
    8      8   
    pub checksum_crc32: ::std::option::Option<::std::string::String>,
    9      9   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   10     10   
    pub checksum_crc32_c: ::std::option::Option<::std::string::String>,
   11     11   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   12     12   
    pub checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
   13         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          13  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   14     14   
    pub checksum_sha1: ::std::option::Option<::std::string::String>,
   15         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          15  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   16     16   
    pub checksum_sha256: ::std::option::Option<::std::string::String>,
   17     17   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   18     18   
    pub checksum_type: ::std::option::Option<crate::types::ChecksumType>,
   19     19   
}
   20     20   
impl Checksum {
   21         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          21  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   22     22   
    pub fn checksum_crc32(&self) -> ::std::option::Option<&str> {
   23     23   
        self.checksum_crc32.as_deref()
   24     24   
    }
   25     25   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   26     26   
    pub fn checksum_crc32_c(&self) -> ::std::option::Option<&str> {
   27     27   
        self.checksum_crc32_c.as_deref()
   28     28   
    }
   29     29   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   30     30   
    pub fn checksum_crc64_nvme(&self) -> ::std::option::Option<&str> {
   31     31   
        self.checksum_crc64_nvme.as_deref()
   32     32   
    }
   33         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          33  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   34     34   
    pub fn checksum_sha1(&self) -> ::std::option::Option<&str> {
   35     35   
        self.checksum_sha1.as_deref()
   36     36   
    }
   37         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          37  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   38     38   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   39     39   
        self.checksum_sha256.as_deref()
   40     40   
    }
   41     41   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   42     42   
    pub fn checksum_type(&self) -> ::std::option::Option<&crate::types::ChecksumType> {
   43     43   
        self.checksum_type.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
impl Checksum {
   47     47   
    /// Creates a new builder-style object to manufacture [`Checksum`](crate::types::Checksum).
   48     48   
    pub fn builder() -> crate::types::builders::ChecksumBuilder {
   49     49   
        crate::types::builders::ChecksumBuilder::default()
   50     50   
    }
   51     51   
}
   52     52   
   53     53   
/// A builder for [`Checksum`](crate::types::Checksum).
   54     54   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   55     55   
#[non_exhaustive]
   56     56   
pub struct ChecksumBuilder {
   57     57   
    pub(crate) checksum_crc32: ::std::option::Option<::std::string::String>,
   58     58   
    pub(crate) checksum_crc32_c: ::std::option::Option<::std::string::String>,
   59     59   
    pub(crate) checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
   60     60   
    pub(crate) checksum_sha1: ::std::option::Option<::std::string::String>,
   61     61   
    pub(crate) checksum_sha256: ::std::option::Option<::std::string::String>,
   62     62   
    pub(crate) checksum_type: ::std::option::Option<crate::types::ChecksumType>,
   63     63   
}
   64     64   
impl ChecksumBuilder {
   65         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          65  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   66     66   
    pub fn checksum_crc32(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   67     67   
        self.checksum_crc32 = ::std::option::Option::Some(input.into());
   68     68   
        self
   69     69   
    }
   70         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          70  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   71     71   
    pub fn set_checksum_crc32(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   72     72   
        self.checksum_crc32 = input;
   73     73   
        self
   74     74   
    }
   75         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only be present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          75  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32 checksum</code> of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   76     76   
    pub fn get_checksum_crc32(&self) -> &::std::option::Option<::std::string::String> {
   77     77   
        &self.checksum_crc32
   78     78   
    }
   79     79   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   80     80   
    pub fn checksum_crc32_c(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   81     81   
        self.checksum_crc32_c = ::std::option::Option::Some(input.into());
   82     82   
        self
   83     83   
    }
   84     84   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   85     85   
    pub fn set_checksum_crc32_c(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   86     86   
        self.checksum_crc32_c = input;
   87     87   
        self
   88     88   
    }
   89     89   
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   90     90   
    pub fn get_checksum_crc32_c(&self) -> &::std::option::Option<::std::string::String> {
   91     91   
        &self.checksum_crc32_c
   92     92   
    }
   93     93   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   94     94   
    pub fn checksum_crc64_nvme(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   95     95   
        self.checksum_crc64_nvme = ::std::option::Option::Some(input.into());
   96     96   
        self
   97     97   
    }
   98     98   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   99     99   
    pub fn set_checksum_crc64_nvme(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  100    100   
        self.checksum_crc64_nvme = input;
  101    101   
        self
  102    102   
    }
  103    103   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  104    104   
    pub fn get_checksum_crc64_nvme(&self) -> &::std::option::Option<::std::string::String> {
  105    105   
        &self.checksum_crc64_nvme
  106    106   
    }
  107         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         107  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  108    108   
    pub fn checksum_sha1(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  109    109   
        self.checksum_sha1 = ::std::option::Option::Some(input.into());
  110    110   
        self
  111    111   
    }
  112         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         112  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  113    113   
    pub fn set_checksum_sha1(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  114    114   
        self.checksum_sha1 = input;
  115    115   
        self
  116    116   
    }
  117         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         117  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use the API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  118    118   
    pub fn get_checksum_sha1(&self) -> &::std::option::Option<::std::string::String> {
  119    119   
        &self.checksum_sha1
  120    120   
    }
  121         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         121  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  122    122   
    pub fn checksum_sha256(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  123    123   
        self.checksum_sha256 = ::std::option::Option::Some(input.into());
  124    124   
        self
  125    125   
    }
  126         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         126  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  127    127   
    pub fn set_checksum_sha256(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  128    128   
        self.checksum_sha256 = input;
  129    129   
        self
  130    130   
    }
  131         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         131  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. When you use an API operation on an object that was uploaded using multipart uploads, this value may not be a direct checksum value of the full object. Instead, it's a calculation based on the checksum values of each individual part. For more information about how checksums are calculated with multipart uploads, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html#large-object-checksums"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  132    132   
    pub fn get_checksum_sha256(&self) -> &::std::option::Option<::std::string::String> {
  133    133   
        &self.checksum_sha256
  134    134   
    }
  135    135   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  136    136   
    pub fn checksum_type(mut self, input: crate::types::ChecksumType) -> Self {
  137    137   
        self.checksum_type = ::std::option::Option::Some(input);
  138    138   
        self
  139    139   
    }
  140    140   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  141    141   
    pub fn set_checksum_type(mut self, input: ::std::option::Option<crate::types::ChecksumType>) -> Self {

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

@@ -1,1 +83,83 @@
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct CopyObjectResult {
    7      7   
    /// <p>Returns the ETag of the new object. The ETag reflects only changes to the contents of an object, not its metadata.</p>
    8      8   
    pub e_tag: ::std::option::Option<::std::string::String>,
    9      9   
    /// <p>Creation date of the object.</p>
   10     10   
    pub last_modified: ::std::option::Option<::aws_smithy_types::DateTime>,
   11     11   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   12     12   
    pub checksum_type: ::std::option::Option<crate::types::ChecksumType>,
   13     13   
    /// <p>The Base64 encoded, 32-bit <code>CRC32</code> checksum of the object. This checksum is only present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   14     14   
    pub checksum_crc32: ::std::option::Option<::std::string::String>,
   15         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          15  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   16     16   
    pub checksum_crc32_c: ::std::option::Option<::std::string::String>,
   17     17   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object being copied was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   18     18   
    pub checksum_crc64_nvme: ::std::option::Option<::std::string::String>,
   19         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          19  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   20     20   
    pub checksum_sha1: ::std::option::Option<::std::string::String>,
   21         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          21  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   22     22   
    pub checksum_sha256: ::std::option::Option<::std::string::String>,
   23     23   
}
   24     24   
impl CopyObjectResult {
   25     25   
    /// <p>Returns the ETag of the new object. The ETag reflects only changes to the contents of an object, not its metadata.</p>
   26     26   
    pub fn e_tag(&self) -> ::std::option::Option<&str> {
   27     27   
        self.e_tag.as_deref()
   28     28   
    }
   29     29   
    /// <p>Creation date of the object.</p>
   30     30   
    pub fn last_modified(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   31     31   
        self.last_modified.as_ref()
   32     32   
    }
   33     33   
    /// <p>The checksum type that is used to calculate the object’s checksum value. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   34     34   
    pub fn checksum_type(&self) -> ::std::option::Option<&crate::types::ChecksumType> {
   35     35   
        self.checksum_type.as_ref()
   36     36   
    }
   37     37   
    /// <p>The Base64 encoded, 32-bit <code>CRC32</code> checksum of the object. This checksum is only present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   38     38   
    pub fn checksum_crc32(&self) -> ::std::option::Option<&str> {
   39     39   
        self.checksum_crc32.as_deref()
   40     40   
    }
   41         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          41  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   42     42   
    pub fn checksum_crc32_c(&self) -> ::std::option::Option<&str> {
   43     43   
        self.checksum_crc32_c.as_deref()
   44     44   
    }
   45     45   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object being copied was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   46     46   
    pub fn checksum_crc64_nvme(&self) -> ::std::option::Option<&str> {
   47     47   
        self.checksum_crc64_nvme.as_deref()
   48     48   
    }
   49         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          49  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   50     50   
    pub fn checksum_sha1(&self) -> ::std::option::Option<&str> {
   51     51   
        self.checksum_sha1.as_deref()
   52     52   
    }
   53         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
          53  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
   54     54   
    pub fn checksum_sha256(&self) -> ::std::option::Option<&str> {
   55     55   
        self.checksum_sha256.as_deref()
   56     56   
    }
   57     57   
}
   58     58   
impl CopyObjectResult {
   59     59   
    /// Creates a new builder-style object to manufacture [`CopyObjectResult`](crate::types::CopyObjectResult).
   60     60   
    pub fn builder() -> crate::types::builders::CopyObjectResultBuilder {
   61     61   
        crate::types::builders::CopyObjectResultBuilder::default()
   62     62   
    }
   63     63   
}
@@ -105,105 +204,204 @@
  125    125   
    }
  126    126   
    /// <p>The Base64 encoded, 32-bit <code>CRC32</code> checksum of the object. This checksum is only present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  127    127   
    pub fn set_checksum_crc32(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  128    128   
        self.checksum_crc32 = input;
  129    129   
        self
  130    130   
    }
  131    131   
    /// <p>The Base64 encoded, 32-bit <code>CRC32</code> checksum of the object. This checksum is only present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  132    132   
    pub fn get_checksum_crc32(&self) -> &::std::option::Option<::std::string::String> {
  133    133   
        &self.checksum_crc32
  134    134   
    }
  135         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         135  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  136    136   
    pub fn checksum_crc32_c(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  137    137   
        self.checksum_crc32_c = ::std::option::Option::Some(input.into());
  138    138   
        self
  139    139   
    }
  140         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         140  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  141    141   
    pub fn set_checksum_crc32_c(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  142    142   
        self.checksum_crc32_c = input;
  143    143   
        self
  144    144   
    }
  145         -
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         145  +
    /// <p>The Base64 encoded, 32-bit <code>CRC32C</code> checksum of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  146    146   
    pub fn get_checksum_crc32_c(&self) -> &::std::option::Option<::std::string::String> {
  147    147   
        &self.checksum_crc32_c
  148    148   
    }
  149    149   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object being copied was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  150    150   
    pub fn checksum_crc64_nvme(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  151    151   
        self.checksum_crc64_nvme = ::std::option::Option::Some(input.into());
  152    152   
        self
  153    153   
    }
  154    154   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object being copied was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  155    155   
    pub fn set_checksum_crc64_nvme(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  156    156   
        self.checksum_crc64_nvme = input;
  157    157   
        self
  158    158   
    }
  159    159   
    /// <p>The Base64 encoded, 64-bit <code>CRC64NVME</code> checksum of the object. This checksum is present if the object being copied was uploaded with the <code>CRC64NVME</code> checksum algorithm, or if the object was uploaded without a checksum (and Amazon S3 added the default checksum, <code>CRC64NVME</code>, to the uploaded object). For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html">Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  160    160   
    pub fn get_checksum_crc64_nvme(&self) -> &::std::option::Option<::std::string::String> {
  161    161   
        &self.checksum_crc64_nvme
  162    162   
    }
  163         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         163  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  164    164   
    pub fn checksum_sha1(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  165    165   
        self.checksum_sha1 = ::std::option::Option::Some(input.into());
  166    166   
        self
  167    167   
    }
  168         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         168  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  169    169   
    pub fn set_checksum_sha1(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  170    170   
        self.checksum_sha1 = input;
  171    171   
        self
  172    172   
    }
  173         -
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         173  +
    /// <p>The Base64 encoded, 160-bit <code>SHA1</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  174    174   
    pub fn get_checksum_sha1(&self) -> &::std::option::Option<::std::string::String> {
  175    175   
        &self.checksum_sha1
  176    176   
    }
  177         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         177  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  178    178   
    pub fn checksum_sha256(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  179    179   
        self.checksum_sha256 = ::std::option::Option::Some(input.into());
  180    180   
        self
  181    181   
    }
  182         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         182  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  183    183   
    pub fn set_checksum_sha256(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  184    184   
        self.checksum_sha256 = input;
  185    185   
        self
  186    186   
    }
  187         -
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This will only be present if the object was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
         187  +
    /// <p>The Base64 encoded, 256-bit <code>SHA256</code> digest of the object. This checksum is only present if the checksum was uploaded with the object. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html"> Checking object integrity</a> in the <i>Amazon S3 User Guide</i>.</p>
  188    188   
    pub fn get_checksum_sha256(&self) -> &::std::option::Option<::std::string::String> {
  189    189   
        &self.checksum_sha256
  190    190   
    }
  191    191   
    /// Consumes the builder and constructs a [`CopyObjectResult`](crate::types::CopyObjectResult).
  192    192   
    pub fn build(self) -> crate::types::CopyObjectResult {
  193    193   
        crate::types::CopyObjectResult {
  194    194   
            e_tag: self.e_tag,
  195    195   
            last_modified: self.last_modified,
  196    196   
            checksum_type: self.checksum_type,
  197    197   
            checksum_crc32: self.checksum_crc32,

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

@@ -1,1 +81,81 @@
   12     12   
    pub location_constraint: ::std::option::Option<crate::types::BucketLocationConstraint>,
   13     13   
    /// <p>Specifies the location where the bucket will be created.</p>
   14     14   
    /// <p><b>Directory buckets </b> - The location type is Availability Zone or Local Zone. To use the Local Zone location type, your account must be enabled for Local Zones. Otherwise, you get an HTTP <code>403 Forbidden</code> error with the error code <code>AccessDenied</code>. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/opt-in-directory-bucket-lz.html">Enable accounts for Local Zones</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   15     15   
    /// <p>This functionality is only supported by directory buckets.</p>
   16     16   
    /// </note>
   17     17   
    pub location: ::std::option::Option<crate::types::LocationInfo>,
   18     18   
    /// <p>Specifies the information about the bucket that will be created.</p><note>
   19     19   
    /// <p>This functionality is only supported by directory buckets.</p>
   20     20   
    /// </note>
   21     21   
    pub bucket: ::std::option::Option<crate::types::BucketInfo>,
   22         -
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p><note>
   23         -
    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
   24         -
    /// </note>
          22  +
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
          23  +
    /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
          24  +
    /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</p>
   25     25   
    pub tags: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>,
   26     26   
}
   27     27   
impl CreateBucketConfiguration {
   28     28   
    /// <p>Specifies the Region where the bucket will be created. You might choose a Region to optimize latency, minimize costs, or address regulatory requirements. For example, if you reside in Europe, you will probably find it advantageous to create buckets in the Europe (Ireland) Region.</p>
   29     29   
    /// <p>If you don't specify a Region, the bucket is created in the US East (N. Virginia) Region (us-east-1) by default. Configurations using the value <code>EU</code> will create a bucket in <code>eu-west-1</code>.</p>
   30     30   
    /// <p>For a list of the valid values for all of the Amazon Web Services Regions, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a>.</p><note>
   31     31   
    /// <p>This functionality is not supported for directory buckets.</p>
   32     32   
    /// </note>
   33     33   
    pub fn location_constraint(&self) -> ::std::option::Option<&crate::types::BucketLocationConstraint> {
   34     34   
        self.location_constraint.as_ref()
   35     35   
    }
   36     36   
    /// <p>Specifies the location where the bucket will be created.</p>
   37     37   
    /// <p><b>Directory buckets </b> - The location type is Availability Zone or Local Zone. To use the Local Zone location type, your account must be enabled for Local Zones. Otherwise, you get an HTTP <code>403 Forbidden</code> error with the error code <code>AccessDenied</code>. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/opt-in-directory-bucket-lz.html">Enable accounts for Local Zones</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   38     38   
    /// <p>This functionality is only supported by directory buckets.</p>
   39     39   
    /// </note>
   40     40   
    pub fn location(&self) -> ::std::option::Option<&crate::types::LocationInfo> {
   41     41   
        self.location.as_ref()
   42     42   
    }
   43     43   
    /// <p>Specifies the information about the bucket that will be created.</p><note>
   44     44   
    /// <p>This functionality is only supported by directory buckets.</p>
   45     45   
    /// </note>
   46     46   
    pub fn bucket(&self) -> ::std::option::Option<&crate::types::BucketInfo> {
   47     47   
        self.bucket.as_ref()
   48     48   
    }
   49         -
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p><note>
   50         -
    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
   51         -
    /// </note>
          49  +
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
          50  +
    /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
          51  +
    /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</p>
   52     52   
    ///
   53     53   
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.tags.is_none()`.
   54     54   
    pub fn tags(&self) -> &[crate::types::Tag] {
   55     55   
        self.tags.as_deref().unwrap_or_default()
   56     56   
    }
   57     57   
}
   58     58   
impl CreateBucketConfiguration {
   59     59   
    /// Creates a new builder-style object to manufacture [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
   60     60   
    pub fn builder() -> crate::types::builders::CreateBucketConfigurationBuilder {
   61     61   
        crate::types::builders::CreateBucketConfigurationBuilder::default()
@@ -118,118 +179,179 @@
  138    138   
    /// <p>Specifies the information about the bucket that will be created.</p><note>
  139    139   
    /// <p>This functionality is only supported by directory buckets.</p>
  140    140   
    /// </note>
  141    141   
    pub fn get_bucket(&self) -> &::std::option::Option<crate::types::BucketInfo> {
  142    142   
        &self.bucket
  143    143   
    }
  144    144   
    /// Appends an item to `tags`.
  145    145   
    ///
  146    146   
    /// To override the contents of this collection use [`set_tags`](Self::set_tags).
  147    147   
    ///
  148         -
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p><note>
  149         -
    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
  150         -
    /// </note>
         148  +
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
         149  +
    /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
         150  +
    /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</p>
  151    151   
    pub fn tags(mut self, input: crate::types::Tag) -> Self {
  152    152   
        let mut v = self.tags.unwrap_or_default();
  153    153   
        v.push(input);
  154    154   
        self.tags = ::std::option::Option::Some(v);
  155    155   
        self
  156    156   
    }
  157         -
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p><note>
  158         -
    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
  159         -
    /// </note>
         157  +
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
         158  +
    /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
         159  +
    /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</p>
  160    160   
    pub fn set_tags(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Tag>>) -> Self {
  161    161   
        self.tags = input;
  162    162   
        self
  163    163   
    }
  164         -
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p><note>
  165         -
    /// <p>This parameter is only supported for S3 directory buckets. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-tagging.html">Using tags with directory buckets</a>.</p>
  166         -
    /// </note>
         164  +
    /// <p>An array of tags that you can apply to the bucket that you're creating. Tags are key-value pairs of metadata used to categorize and organize your buckets, track costs, and control access.</p>
         165  +
    /// <p>You must have the <code>s3:TagResource</code> permission to create a general purpose bucket with tags or the <code>s3express:TagResource</code> permission to create a directory bucket with tags.</p>
         166  +
    /// <p>When creating buckets with tags, note that tag-based conditions using <code>aws:ResourceTag</code> and <code>s3:BucketTag</code> condition keys are applicable only after ABAC is enabled on the bucket. To learn more, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/buckets-tagging-enable-abac.html">Enabling ABAC in general purpose buckets</a>.</p>
  167    167   
    pub fn get_tags(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Tag>> {
  168    168   
        &self.tags
  169    169   
    }
  170    170   
    /// Consumes the builder and constructs a [`CreateBucketConfiguration`](crate::types::CreateBucketConfiguration).
  171    171   
    pub fn build(self) -> crate::types::CreateBucketConfiguration {
  172    172   
        crate::types::CreateBucketConfiguration {
  173    173   
            location_constraint: self.location_constraint,
  174    174   
            location: self.location,
  175    175   
            bucket: self.bucket,
  176    176   
            tags: self.tags,

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

@@ -0,1 +0,108 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
           3  +
/// When writing a match expression against `EncryptionType`, it is important to ensure
           4  +
/// your code is forward-compatible. That is, if a match arm handles a case for a
           5  +
/// feature that is supported by the service but has not been represented as an enum
           6  +
/// variant in a current version of SDK, your code should continue to work when you
           7  +
/// upgrade SDK to a future version in which the enum does include a variant for that
           8  +
/// feature.
           9  +
///
          10  +
/// Here is an example of how you can make a match expression forward-compatible:
          11  +
///
          12  +
/// ```text
          13  +
/// # let encryptiontype = unimplemented!();
          14  +
/// match encryptiontype {
          15  +
///     EncryptionType::None => { /* ... */ },
          16  +
///     EncryptionType::SseC => { /* ... */ },
          17  +
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          18  +
///     _ => { /* ... */ },
          19  +
/// }
          20  +
/// ```
          21  +
/// The above code demonstrates that when `encryptiontype` represents
          22  +
/// `NewFeature`, the execution path will lead to the second last match arm,
          23  +
/// even though the enum does not contain a variant `EncryptionType::NewFeature`
          24  +
/// in the current version of SDK. The reason is that the variable `other`,
          25  +
/// created by the `@` operator, is bound to
          26  +
/// `EncryptionType::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
          27  +
/// and calling `as_str` on it yields `"NewFeature"`.
          28  +
/// This match expression is forward-compatible when executed with a newer
          29  +
/// version of SDK where the variant `EncryptionType::NewFeature` is defined.
          30  +
/// Specifically, when `encryptiontype` represents `NewFeature`,
          31  +
/// the execution path will hit the second last match arm as before by virtue of
          32  +
/// calling `as_str` on `EncryptionType::NewFeature` also yielding `"NewFeature"`.
          33  +
///
          34  +
/// Explicitly matching on the `Unknown` variant should
          35  +
/// be avoided for two reasons:
          36  +
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
          37  +
/// - It might inadvertently shadow other intended match arms.
          38  +
///
          39  +
#[allow(missing_docs)] // documentation missing in model
          40  +
#[non_exhaustive]
          41  +
#[derive(
          42  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
          43  +
)]
          44  +
pub enum EncryptionType {
          45  +
    #[allow(missing_docs)] // documentation missing in model
          46  +
    None,
          47  +
    #[allow(missing_docs)] // documentation missing in model
          48  +
    SseC,
          49  +
    /// `Unknown` contains new variants that have been added since this code was generated.
          50  +
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
          51  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          52  +
}
          53  +
impl ::std::convert::From<&str> for EncryptionType {
          54  +
    fn from(s: &str) -> Self {
          55  +
        match s {
          56  +
            "NONE" => EncryptionType::None,
          57  +
            "SSE-C" => EncryptionType::SseC,
          58  +
            other => EncryptionType::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
          59  +
        }
          60  +
    }
          61  +
}
          62  +
impl ::std::str::FromStr for EncryptionType {
          63  +
    type Err = ::std::convert::Infallible;
          64  +
          65  +
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
          66  +
        ::std::result::Result::Ok(EncryptionType::from(s))
          67  +
    }
          68  +
}
          69  +
impl EncryptionType {
          70  +
    /// Returns the `&str` value of the enum member.
          71  +
    pub fn as_str(&self) -> &str {
          72  +
        match self {
          73  +
            EncryptionType::None => "NONE",
          74  +
            EncryptionType::SseC => "SSE-C",
          75  +
            EncryptionType::Unknown(value) => value.as_str(),
          76  +
        }
          77  +
    }
          78  +
    /// Returns all the `&str` representations of the enum members.
          79  +
    pub const fn values() -> &'static [&'static str] {
          80  +
        &["NONE", "SSE-C"]
          81  +
    }
          82  +
}
          83  +
impl ::std::convert::AsRef<str> for EncryptionType {
          84  +
    fn as_ref(&self) -> &str {
          85  +
        self.as_str()
          86  +
    }
          87  +
}
          88  +
impl EncryptionType {
          89  +
    /// Parses the enum value while disallowing unknown variants.
          90  +
    ///
          91  +
    /// Unknown variants will result in an error.
          92  +
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
          93  +
        match Self::from(value) {
          94  +
            #[allow(deprecated)]
          95  +
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
          96  +
            known => Ok(known),
          97  +
        }
          98  +
    }
          99  +
}
         100  +
impl ::std::fmt::Display for EncryptionType {
         101  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
         102  +
        match self {
         103  +
            EncryptionType::None => write!(f, "NONE"),
         104  +
            EncryptionType::SseC => write!(f, "SSE-C"),
         105  +
            EncryptionType::Unknown(value) => write!(f, "{value}"),
         106  +
        }
         107  +
    }
         108  +
}

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

@@ -1,1 +217,112 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3      3   
/// <p>Container for the person being granted permissions.</p>
    4      4   
#[non_exhaustive]
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct Grantee {
    7         -
    /// <p>Screen name of the grantee.</p>
           7  +
    /// <p></p>
    8      8   
    pub display_name: ::std::option::Option<::std::string::String>,
    9         -
    /// <p>Email address of the grantee.</p><note>
   10         -
    /// <p>Using email addresses to specify a grantee is only supported in the following Amazon Web Services Regions:</p>
   11         -
    /// <ul>
   12         -
    /// <li>
   13         -
    /// <p>US East (N. Virginia)</p></li>
   14         -
    /// <li>
   15         -
    /// <p>US West (N. California)</p></li>
   16         -
    /// <li>
   17         -
    /// <p>US West (Oregon)</p></li>
   18         -
    /// <li>
   19         -
    /// <p>Asia Pacific (Singapore)</p></li>
   20         -
    /// <li>
   21         -
    /// <p>Asia Pacific (Sydney)</p></li>
   22         -
    /// <li>
   23         -
    /// <p>Asia Pacific (Tokyo)</p></li>
   24         -
    /// <li>
   25         -
    /// <p>Europe (Ireland)</p></li>
   26         -
    /// <li>
   27         -
    /// <p>South America (São Paulo)</p></li>
   28         -
    /// </ul>
   29         -
    /// <p>For a list of all the Amazon S3 supported Regions and endpoints, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a> in the Amazon Web Services General Reference.</p>
   30         -
    /// </note>
           9  +
    /// <p></p>
   31     10   
    pub email_address: ::std::option::Option<::std::string::String>,
   32     11   
    /// <p>The canonical user ID of the grantee.</p>
   33     12   
    pub id: ::std::option::Option<::std::string::String>,
   34     13   
    /// <p>URI of the grantee group.</p>
   35     14   
    pub uri: ::std::option::Option<::std::string::String>,
   36     15   
    /// <p>Type of grantee</p>
   37     16   
    pub r#type: crate::types::Type,
   38     17   
}
   39     18   
impl Grantee {
   40         -
    /// <p>Screen name of the grantee.</p>
          19  +
    /// <p></p>
   41     20   
    pub fn display_name(&self) -> ::std::option::Option<&str> {
   42     21   
        self.display_name.as_deref()
   43     22   
    }
   44         -
    /// <p>Email address of the grantee.</p><note>
   45         -
    /// <p>Using email addresses to specify a grantee is only supported in the following Amazon Web Services Regions:</p>
   46         -
    /// <ul>
   47         -
    /// <li>
   48         -
    /// <p>US East (N. Virginia)</p></li>
   49         -
    /// <li>
   50         -
    /// <p>US West (N. California)</p></li>
   51         -
    /// <li>
   52         -
    /// <p>US West (Oregon)</p></li>
   53         -
    /// <li>
   54         -
    /// <p>Asia Pacific (Singapore)</p></li>
   55         -
    /// <li>
   56         -
    /// <p>Asia Pacific (Sydney)</p></li>
   57         -
    /// <li>
   58         -
    /// <p>Asia Pacific (Tokyo)</p></li>
   59         -
    /// <li>
   60         -
    /// <p>Europe (Ireland)</p></li>
   61         -
    /// <li>
   62         -
    /// <p>South America (São Paulo)</p></li>
   63         -
    /// </ul>
   64         -
    /// <p>For a list of all the Amazon S3 supported Regions and endpoints, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a> in the Amazon Web Services General Reference.</p>
   65         -
    /// </note>
          23  +
    /// <p></p>
   66     24   
    pub fn email_address(&self) -> ::std::option::Option<&str> {
   67     25   
        self.email_address.as_deref()
   68     26   
    }
   69     27   
    /// <p>The canonical user ID of the grantee.</p>
   70     28   
    pub fn id(&self) -> ::std::option::Option<&str> {
   71     29   
        self.id.as_deref()
   72     30   
    }
   73     31   
    /// <p>URI of the grantee group.</p>
   74     32   
    pub fn uri(&self) -> ::std::option::Option<&str> {
   75     33   
        self.uri.as_deref()
   76     34   
    }
   77     35   
    /// <p>Type of grantee</p>
   78     36   
    pub fn r#type(&self) -> &crate::types::Type {
   79     37   
        &self.r#type
   80     38   
    }
   81     39   
}
   82     40   
impl Grantee {
   83     41   
    /// Creates a new builder-style object to manufacture [`Grantee`](crate::types::Grantee).
   84     42   
    pub fn builder() -> crate::types::builders::GranteeBuilder {
   85     43   
        crate::types::builders::GranteeBuilder::default()
   86     44   
    }
   87     45   
}
   88     46   
   89     47   
/// A builder for [`Grantee`](crate::types::Grantee).
   90     48   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   91     49   
#[non_exhaustive]
   92     50   
pub struct GranteeBuilder {
   93     51   
    pub(crate) display_name: ::std::option::Option<::std::string::String>,
   94     52   
    pub(crate) email_address: ::std::option::Option<::std::string::String>,
   95     53   
    pub(crate) id: ::std::option::Option<::std::string::String>,
   96     54   
    pub(crate) uri: ::std::option::Option<::std::string::String>,
   97     55   
    pub(crate) r#type: ::std::option::Option<crate::types::Type>,
   98     56   
}
   99     57   
impl GranteeBuilder {
  100         -
    /// <p>Screen name of the grantee.</p>
          58  +
    /// <p></p>
  101     59   
    pub fn display_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  102     60   
        self.display_name = ::std::option::Option::Some(input.into());
  103     61   
        self
  104     62   
    }
  105         -
    /// <p>Screen name of the grantee.</p>
          63  +
    /// <p></p>
  106     64   
    pub fn set_display_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  107     65   
        self.display_name = input;
  108     66   
        self
  109     67   
    }
  110         -
    /// <p>Screen name of the grantee.</p>
          68  +
    /// <p></p>
  111     69   
    pub fn get_display_name(&self) -> &::std::option::Option<::std::string::String> {
  112     70   
        &self.display_name
  113     71   
    }
  114         -
    /// <p>Email address of the grantee.</p><note>
  115         -
    /// <p>Using email addresses to specify a grantee is only supported in the following Amazon Web Services Regions:</p>
  116         -
    /// <ul>
  117         -
    /// <li>
  118         -
    /// <p>US East (N. Virginia)</p></li>
  119         -
    /// <li>
  120         -
    /// <p>US West (N. California)</p></li>
  121         -
    /// <li>
  122         -
    /// <p>US West (Oregon)</p></li>
  123         -
    /// <li>
  124         -
    /// <p>Asia Pacific (Singapore)</p></li>
  125         -
    /// <li>
  126         -
    /// <p>Asia Pacific (Sydney)</p></li>
  127         -
    /// <li>
  128         -
    /// <p>Asia Pacific (Tokyo)</p></li>
  129         -
    /// <li>
  130         -
    /// <p>Europe (Ireland)</p></li>
  131         -
    /// <li>
  132         -
    /// <p>South America (São Paulo)</p></li>
  133         -
    /// </ul>
  134         -
    /// <p>For a list of all the Amazon S3 supported Regions and endpoints, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a> in the Amazon Web Services General Reference.</p>
  135         -
    /// </note>
          72  +
    /// <p></p>
  136     73   
    pub fn email_address(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  137     74   
        self.email_address = ::std::option::Option::Some(input.into());
  138     75   
        self
  139     76   
    }
  140         -
    /// <p>Email address of the grantee.</p><note>
  141         -
    /// <p>Using email addresses to specify a grantee is only supported in the following Amazon Web Services Regions:</p>
  142         -
    /// <ul>
  143         -
    /// <li>
  144         -
    /// <p>US East (N. Virginia)</p></li>
  145         -
    /// <li>
  146         -
    /// <p>US West (N. California)</p></li>
  147         -
    /// <li>
  148         -
    /// <p>US West (Oregon)</p></li>
  149         -
    /// <li>
  150         -
    /// <p>Asia Pacific (Singapore)</p></li>
  151         -
    /// <li>
  152         -
    /// <p>Asia Pacific (Sydney)</p></li>
  153         -
    /// <li>
  154         -
    /// <p>Asia Pacific (Tokyo)</p></li>
  155         -
    /// <li>
  156         -
    /// <p>Europe (Ireland)</p></li>
  157         -
    /// <li>
  158         -
    /// <p>South America (São Paulo)</p></li>
  159         -
    /// </ul>
  160         -
    /// <p>For a list of all the Amazon S3 supported Regions and endpoints, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a> in the Amazon Web Services General Reference.</p>
  161         -
    /// </note>
          77  +
    /// <p></p>
  162     78   
    pub fn set_email_address(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  163     79   
        self.email_address = input;
  164     80   
        self
  165     81   
    }
  166         -
    /// <p>Email address of the grantee.</p><note>
  167         -
    /// <p>Using email addresses to specify a grantee is only supported in the following Amazon Web Services Regions:</p>
  168         -
    /// <ul>
  169         -
    /// <li>
  170         -
    /// <p>US East (N. Virginia)</p></li>
  171         -
    /// <li>
  172         -
    /// <p>US West (N. California)</p></li>
  173         -
    /// <li>
  174         -
    /// <p>US West (Oregon)</p></li>
  175         -
    /// <li>
  176         -
    /// <p>Asia Pacific (Singapore)</p></li>
  177         -
    /// <li>
  178         -
    /// <p>Asia Pacific (Sydney)</p></li>
  179         -
    /// <li>
  180         -
    /// <p>Asia Pacific (Tokyo)</p></li>
  181         -
    /// <li>
  182         -
    /// <p>Europe (Ireland)</p></li>
  183         -
    /// <li>
  184         -
    /// <p>South America (São Paulo)</p></li>
  185         -
    /// </ul>
  186         -
    /// <p>For a list of all the Amazon S3 supported Regions and endpoints, see <a href="https://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region">Regions and Endpoints</a> in the Amazon Web Services General Reference.</p>
  187         -
    /// </note>
          82  +
    /// <p></p>
  188     83   
    pub fn get_email_address(&self) -> &::std::option::Option<::std::string::String> {
  189     84   
        &self.email_address
  190     85   
    }
  191     86   
    /// <p>The canonical user ID of the grantee.</p>
  192     87   
    pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  193     88   
        self.id = ::std::option::Option::Some(input.into());
  194     89   
        self
  195     90   
    }
  196     91   
    /// <p>The canonical user ID of the grantee.</p>
  197     92   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

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

@@ -1,1 +92,92 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3      3   
/// <p>Container element that identifies who initiated the multipart upload.</p>
    4      4   
#[non_exhaustive]
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct Initiator {
    7      7   
    /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
    8      8   
    /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
    9      9   
    /// </note>
   10     10   
    pub id: ::std::option::Option<::std::string::String>,
   11         -
    /// <p>Name of the Principal.</p><note>
          11  +
    /// <p></p><note>
   12     12   
    /// <p>This functionality is not supported for directory buckets.</p>
   13     13   
    /// </note>
   14     14   
    pub display_name: ::std::option::Option<::std::string::String>,
   15     15   
}
   16     16   
impl Initiator {
   17     17   
    /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
   18     18   
    /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
   19     19   
    /// </note>
   20     20   
    pub fn id(&self) -> ::std::option::Option<&str> {
   21     21   
        self.id.as_deref()
   22     22   
    }
   23         -
    /// <p>Name of the Principal.</p><note>
          23  +
    /// <p></p><note>
   24     24   
    /// <p>This functionality is not supported for directory buckets.</p>
   25     25   
    /// </note>
   26     26   
    pub fn display_name(&self) -> ::std::option::Option<&str> {
   27     27   
        self.display_name.as_deref()
   28     28   
    }
   29     29   
}
   30     30   
impl Initiator {
   31     31   
    /// Creates a new builder-style object to manufacture [`Initiator`](crate::types::Initiator).
   32     32   
    pub fn builder() -> crate::types::builders::InitiatorBuilder {
   33     33   
        crate::types::builders::InitiatorBuilder::default()
   34     34   
    }
   35     35   
}
   36     36   
   37     37   
/// A builder for [`Initiator`](crate::types::Initiator).
   38     38   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   39     39   
#[non_exhaustive]
   40     40   
pub struct InitiatorBuilder {
   41     41   
    pub(crate) id: ::std::option::Option<::std::string::String>,
   42     42   
    pub(crate) display_name: ::std::option::Option<::std::string::String>,
   43     43   
}
   44     44   
impl InitiatorBuilder {
   45     45   
    /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
   46     46   
    /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
   47     47   
    /// </note>
   48     48   
    pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   49     49   
        self.id = ::std::option::Option::Some(input.into());
   50     50   
        self
   51     51   
    }
   52     52   
    /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
   53     53   
    /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
   54     54   
    /// </note>
   55     55   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   56     56   
        self.id = input;
   57     57   
        self
   58     58   
    }
   59     59   
    /// <p>If the principal is an Amazon Web Services account, it provides the Canonical User ID. If the principal is an IAM User, it provides a user ARN value.</p><note>
   60     60   
    /// <p><b>Directory buckets</b> - If the principal is an Amazon Web Services account, it provides the Amazon Web Services account ID. If the principal is an IAM User, it provides a user ARN value.</p>
   61     61   
    /// </note>
   62     62   
    pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
   63     63   
        &self.id
   64     64   
    }
   65         -
    /// <p>Name of the Principal.</p><note>
          65  +
    /// <p></p><note>
   66     66   
    /// <p>This functionality is not supported for directory buckets.</p>
   67     67   
    /// </note>
   68     68   
    pub fn display_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
   69     69   
        self.display_name = ::std::option::Option::Some(input.into());
   70     70   
        self
   71     71   
    }
   72         -
    /// <p>Name of the Principal.</p><note>
          72  +
    /// <p></p><note>
   73     73   
    /// <p>This functionality is not supported for directory buckets.</p>
   74     74   
    /// </note>
   75     75   
    pub fn set_display_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
   76     76   
        self.display_name = input;
   77     77   
        self
   78     78   
    }
   79         -
    /// <p>Name of the Principal.</p><note>
          79  +
    /// <p></p><note>
   80     80   
    /// <p>This functionality is not supported for directory buckets.</p>
   81     81   
    /// </note>
   82     82   
    pub fn get_display_name(&self) -> &::std::option::Option<::std::string::String> {
   83     83   
        &self.display_name
   84     84   
    }
   85     85   
    /// Consumes the builder and constructs a [`Initiator`](crate::types::Initiator).
   86     86   
    pub fn build(self) -> crate::types::Initiator {
   87     87   
        crate::types::Initiator {
   88     88   
            id: self.id,
   89     89   
            display_name: self.display_name,

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

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

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

@@ -1,1 +78,78 @@
    2      2   
    3      3   
/// <p>A lifecycle rule for individual objects in an Amazon S3 bucket.</p>
    4      4   
/// <p>For more information see, <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-lifecycle-mgmt.html">Managing your storage lifecycle</a> in the <i>Amazon S3 User Guide</i>.</p>
    5      5   
#[non_exhaustive]
    6      6   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    7      7   
pub struct LifecycleRule {
    8      8   
    /// <p>Specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker.</p>
    9      9   
    pub expiration: ::std::option::Option<crate::types::LifecycleExpiration>,
   10     10   
    /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
   11     11   
    pub id: ::std::option::Option<::std::string::String>,
   12         -
    /// <p>Prefix identifying one or more objects to which the rule applies. This is no longer used; use <code>Filter</code> instead.</p><important>
          12  +
    /// <p>The general purpose bucket prefix that identifies one or more objects to which the rule applies. We recommend using <code>Filter</code> instead of <code>Prefix</code> for new PUTs. Previous configurations where a prefix is defined will continue to operate as before.</p><important>
   13     13   
    /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
   14     14   
    /// </important>
   15     15   
    #[deprecated]
   16     16   
    pub prefix: ::std::option::Option<::std::string::String>,
   17     17   
    /// <p>The <code>Filter</code> is used to identify objects that a Lifecycle Rule applies to. A <code>Filter</code> must have exactly one of <code>Prefix</code>, <code>Tag</code>, <code>ObjectSizeGreaterThan</code>, <code>ObjectSizeLessThan</code>, or <code>And</code> specified. <code>Filter</code> is required if the <code>LifecycleRule</code> does not contain a <code>Prefix</code> element.</p>
   18     18   
    /// <p>For more information about <code>Tag</code> filters, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/intro-lifecycle-filters.html">Adding filters to Lifecycle rules</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   19     19   
    /// <p><code>Tag</code> filters are not supported for directory buckets.</p>
   20     20   
    /// </note>
   21     21   
    pub filter: ::std::option::Option<crate::types::LifecycleRuleFilter>,
   22     22   
    /// <p>If 'Enabled', the rule is currently being applied. If 'Disabled', the rule is not currently being applied.</p>
   23     23   
    pub status: crate::types::ExpirationStatus,
   24     24   
    /// <p>Specifies when an Amazon S3 object transitions to a specified storage class.</p><note>
   25     25   
    /// <p>This parameter applies to general purpose buckets only. It is not supported for directory bucket lifecycle configurations.</p>
   26     26   
    /// </note>
   27     27   
    pub transitions: ::std::option::Option<::std::vec::Vec<crate::types::Transition>>,
   28     28   
    /// <p>Specifies the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class. If your bucket is versioning-enabled (or versioning is suspended), you can set this action to request that Amazon S3 transition noncurrent object versions to a specific storage class at a set period in the object's lifetime.</p><note>
   29     29   
    /// <p>This parameter applies to general purpose buckets only. It is not supported for directory bucket lifecycle configurations.</p>
   30     30   
    /// </note>
   31     31   
    pub noncurrent_version_transitions: ::std::option::Option<::std::vec::Vec<crate::types::NoncurrentVersionTransition>>,
   32     32   
    /// <p>Specifies when noncurrent object versions expire. Upon expiration, Amazon S3 permanently deletes the noncurrent object versions. You set this lifecycle configuration action on a bucket that has versioning enabled (or suspended) to request that Amazon S3 delete noncurrent object versions at a specific period in the object's lifetime.</p><note>
   33     33   
    /// <p>This parameter applies to general purpose buckets only. It is not supported for directory bucket lifecycle configurations.</p>
   34     34   
    /// </note>
   35     35   
    pub noncurrent_version_expiration: ::std::option::Option<crate::types::NoncurrentVersionExpiration>,
   36     36   
    /// <p>Specifies the days since the initiation of an incomplete multipart upload that Amazon S3 will wait before permanently removing all parts of the upload. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/mpuoverview.html#mpu-abort-incomplete-mpu-lifecycle-config"> Aborting Incomplete Multipart Uploads Using a Bucket Lifecycle Configuration</a> in the <i>Amazon S3 User Guide</i>.</p>
   37     37   
    pub abort_incomplete_multipart_upload: ::std::option::Option<crate::types::AbortIncompleteMultipartUpload>,
   38     38   
}
   39     39   
impl LifecycleRule {
   40     40   
    /// <p>Specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker.</p>
   41     41   
    pub fn expiration(&self) -> ::std::option::Option<&crate::types::LifecycleExpiration> {
   42     42   
        self.expiration.as_ref()
   43     43   
    }
   44     44   
    /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
   45     45   
    pub fn id(&self) -> ::std::option::Option<&str> {
   46     46   
        self.id.as_deref()
   47     47   
    }
   48         -
    /// <p>Prefix identifying one or more objects to which the rule applies. This is no longer used; use <code>Filter</code> instead.</p><important>
          48  +
    /// <p>The general purpose bucket prefix that identifies one or more objects to which the rule applies. We recommend using <code>Filter</code> instead of <code>Prefix</code> for new PUTs. Previous configurations where a prefix is defined will continue to operate as before.</p><important>
   49     49   
    /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
   50     50   
    /// </important>
   51     51   
    #[deprecated]
   52     52   
    pub fn prefix(&self) -> ::std::option::Option<&str> {
   53     53   
        self.prefix.as_deref()
   54     54   
    }
   55     55   
    /// <p>The <code>Filter</code> is used to identify objects that a Lifecycle Rule applies to. A <code>Filter</code> must have exactly one of <code>Prefix</code>, <code>Tag</code>, <code>ObjectSizeGreaterThan</code>, <code>ObjectSizeLessThan</code>, or <code>And</code> specified. <code>Filter</code> is required if the <code>LifecycleRule</code> does not contain a <code>Prefix</code> element.</p>
   56     56   
    /// <p>For more information about <code>Tag</code> filters, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/intro-lifecycle-filters.html">Adding filters to Lifecycle rules</a> in the <i>Amazon S3 User Guide</i>.</p><note>
   57     57   
    /// <p><code>Tag</code> filters are not supported for directory buckets.</p>
   58     58   
    /// </note>
@@ -113,113 +189,189 @@
  133    133   
    }
  134    134   
    /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
  135    135   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  136    136   
        self.id = input;
  137    137   
        self
  138    138   
    }
  139    139   
    /// <p>Unique identifier for the rule. The value cannot be longer than 255 characters.</p>
  140    140   
    pub fn get_id(&self) -> &::std::option::Option<::std::string::String> {
  141    141   
        &self.id
  142    142   
    }
  143         -
    /// <p>Prefix identifying one or more objects to which the rule applies. This is no longer used; use <code>Filter</code> instead.</p><important>
         143  +
    /// <p>The general purpose bucket prefix that identifies one or more objects to which the rule applies. We recommend using <code>Filter</code> instead of <code>Prefix</code> for new PUTs. Previous configurations where a prefix is defined will continue to operate as before.</p><important>
  144    144   
    /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
  145    145   
    /// </important>
  146    146   
    #[deprecated]
  147    147   
    pub fn prefix(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  148    148   
        self.prefix = ::std::option::Option::Some(input.into());
  149    149   
        self
  150    150   
    }
  151         -
    /// <p>Prefix identifying one or more objects to which the rule applies. This is no longer used; use <code>Filter</code> instead.</p><important>
         151  +
    /// <p>The general purpose bucket prefix that identifies one or more objects to which the rule applies. We recommend using <code>Filter</code> instead of <code>Prefix</code> for new PUTs. Previous configurations where a prefix is defined will continue to operate as before.</p><important>
  152    152   
    /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
  153    153   
    /// </important>
  154    154   
    #[deprecated]
  155    155   
    pub fn set_prefix(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  156    156   
        self.prefix = input;
  157    157   
        self
  158    158   
    }
  159         -
    /// <p>Prefix identifying one or more objects to which the rule applies. This is no longer used; use <code>Filter</code> instead.</p><important>
         159  +
    /// <p>The general purpose bucket prefix that identifies one or more objects to which the rule applies. We recommend using <code>Filter</code> instead of <code>Prefix</code> for new PUTs. Previous configurations where a prefix is defined will continue to operate as before.</p><important>
  160    160   
    /// <p>Replacement must be made for object keys containing special characters (such as carriage returns) when using XML requests. For more information, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints"> XML related object key constraints</a>.</p>
  161    161   
    /// </important>
  162    162   
    #[deprecated]
  163    163   
    pub fn get_prefix(&self) -> &::std::option::Option<::std::string::String> {
  164    164   
        &self.prefix
  165    165   
    }
  166    166   
    /// <p>The <code>Filter</code> is used to identify objects that a Lifecycle Rule applies to. A <code>Filter</code> must have exactly one of <code>Prefix</code>, <code>Tag</code>, <code>ObjectSizeGreaterThan</code>, <code>ObjectSizeLessThan</code>, or <code>And</code> specified. <code>Filter</code> is required if the <code>LifecycleRule</code> does not contain a <code>Prefix</code> element.</p>
  167    167   
    /// <p>For more information about <code>Tag</code> filters, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/userguide/intro-lifecycle-filters.html">Adding filters to Lifecycle rules</a> in the <i>Amazon S3 User Guide</i>.</p><note>
  168    168   
    /// <p><code>Tag</code> filters are not supported for directory buckets.</p>
  169    169   
    /// </note>

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

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

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

@@ -1,1 +176,72 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3         -
/// <important>
    4         -
/// <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>
    5         -
/// <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>
    6         -
/// </important>
    7      3   
/// <p>Container for the owner's display name and ID.</p>
    8      4   
#[non_exhaustive]
    9      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
   10      6   
pub struct Owner {
   11         -
    /// <p>Container for the display name of the owner. This value is only supported in the following Amazon Web Services Regions:</p>
   12         -
    /// <ul>
   13         -
    /// <li>
   14         -
    /// <p>US East (N. Virginia)</p></li>
   15         -
    /// <li>
   16         -
    /// <p>US West (N. California)</p></li>
   17         -
    /// <li>
   18         -
    /// <p>US West (Oregon)</p></li>
   19         -
    /// <li>
   20         -
    /// <p>Asia Pacific (Singapore)</p></li>
   21         -
    /// <li>
   22         -
    /// <p>Asia Pacific (Sydney)</p></li>
   23         -
    /// <li>
   24         -
    /// <p>Asia Pacific (Tokyo)</p></li>
   25         -
    /// <li>
   26         -
    /// <p>Europe (Ireland)</p></li>
   27         -
    /// <li>
   28         -
    /// <p>South America (São Paulo)</p></li>
   29         -
    /// </ul><note>
   30         -
    /// <p>This functionality is not supported for directory buckets.</p>
   31         -
    /// </note>
           7  +
    /// <p></p>
   32      8   
    pub display_name: ::std::option::Option<::std::string::String>,
   33      9   
    /// <p>Container for the ID of the owner.</p>
   34     10   
    pub id: ::std::option::Option<::std::string::String>,
   35     11   
}
   36     12   
impl Owner {
   37         -
    /// <p>Container for the display name of the owner. This value is only supported in the following Amazon Web Services Regions:</p>
   38         -
    /// <ul>
   39         -
    /// <li>
   40         -
    /// <p>US East (N. Virginia)</p></li>
   41         -
    /// <li>
   42         -
    /// <p>US West (N. California)</p></li>
   43         -
    /// <li>
   44         -
    /// <p>US West (Oregon)</p></li>
   45         -
    /// <li>
   46         -
    /// <p>Asia Pacific (Singapore)</p></li>
   47         -
    /// <li>
   48         -
    /// <p>Asia Pacific (Sydney)</p></li>
   49         -
    /// <li>
   50         -
    /// <p>Asia Pacific (Tokyo)</p></li>
   51         -
    /// <li>
   52         -
    /// <p>Europe (Ireland)</p></li>
   53         -
    /// <li>
   54         -
    /// <p>South America (São Paulo)</p></li>
   55         -
    /// </ul><note>
   56         -
    /// <p>This functionality is not supported for directory buckets.</p>
   57         -
    /// </note>
          13  +
    /// <p></p>
   58     14   
    pub fn display_name(&self) -> ::std::option::Option<&str> {
   59     15   
        self.display_name.as_deref()
   60     16   
    }
   61     17   
    /// <p>Container for the ID of the owner.</p>
   62     18   
    pub fn id(&self) -> ::std::option::Option<&str> {
   63     19   
        self.id.as_deref()
   64     20   
    }
   65     21   
}
   66     22   
impl Owner {
   67     23   
    /// Creates a new builder-style object to manufacture [`Owner`](crate::types::Owner).
   68     24   
    pub fn builder() -> crate::types::builders::OwnerBuilder {
   69     25   
        crate::types::builders::OwnerBuilder::default()
   70     26   
    }
   71     27   
}
   72     28   
   73     29   
/// A builder for [`Owner`](crate::types::Owner).
   74     30   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   75     31   
#[non_exhaustive]
   76     32   
pub struct OwnerBuilder {
   77     33   
    pub(crate) display_name: ::std::option::Option<::std::string::String>,
   78     34   
    pub(crate) id: ::std::option::Option<::std::string::String>,
   79     35   
}
   80     36   
impl OwnerBuilder {
   81         -
    /// <p>Container for the display name of the owner. This value is only supported in the following Amazon Web Services Regions:</p>
   82         -
    /// <ul>
   83         -
    /// <li>
   84         -
    /// <p>US East (N. Virginia)</p></li>
   85         -
    /// <li>
   86         -
    /// <p>US West (N. California)</p></li>
   87         -
    /// <li>
   88         -
    /// <p>US West (Oregon)</p></li>
   89         -
    /// <li>
   90         -
    /// <p>Asia Pacific (Singapore)</p></li>
   91         -
    /// <li>
   92         -
    /// <p>Asia Pacific (Sydney)</p></li>
   93         -
    /// <li>
   94         -
    /// <p>Asia Pacific (Tokyo)</p></li>
   95         -
    /// <li>
   96         -
    /// <p>Europe (Ireland)</p></li>
   97         -
    /// <li>
   98         -
    /// <p>South America (São Paulo)</p></li>
   99         -
    /// </ul><note>
  100         -
    /// <p>This functionality is not supported for directory buckets.</p>
  101         -
    /// </note>
          37  +
    /// <p></p>
  102     38   
    pub fn display_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  103     39   
        self.display_name = ::std::option::Option::Some(input.into());
  104     40   
        self
  105     41   
    }
  106         -
    /// <p>Container for the display name of the owner. This value is only supported in the following Amazon Web Services Regions:</p>
  107         -
    /// <ul>
  108         -
    /// <li>
  109         -
    /// <p>US East (N. Virginia)</p></li>
  110         -
    /// <li>
  111         -
    /// <p>US West (N. California)</p></li>
  112         -
    /// <li>
  113         -
    /// <p>US West (Oregon)</p></li>
  114         -
    /// <li>
  115         -
    /// <p>Asia Pacific (Singapore)</p></li>
  116         -
    /// <li>
  117         -
    /// <p>Asia Pacific (Sydney)</p></li>
  118         -
    /// <li>
  119         -
    /// <p>Asia Pacific (Tokyo)</p></li>
  120         -
    /// <li>
  121         -
    /// <p>Europe (Ireland)</p></li>
  122         -
    /// <li>
  123         -
    /// <p>South America (São Paulo)</p></li>
  124         -
    /// </ul><note>
  125         -
    /// <p>This functionality is not supported for directory buckets.</p>
  126         -
    /// </note>
          42  +
    /// <p></p>
  127     43   
    pub fn set_display_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  128     44   
        self.display_name = input;
  129     45   
        self
  130     46   
    }
  131         -
    /// <p>Container for the display name of the owner. This value is only supported in the following Amazon Web Services Regions:</p>
  132         -
    /// <ul>
  133         -
    /// <li>
  134         -
    /// <p>US East (N. Virginia)</p></li>
  135         -
    /// <li>
  136         -
    /// <p>US West (N. California)</p></li>
  137         -
    /// <li>
  138         -
    /// <p>US West (Oregon)</p></li>
  139         -
    /// <li>
  140         -
    /// <p>Asia Pacific (Singapore)</p></li>
  141         -
    /// <li>
  142         -
    /// <p>Asia Pacific (Sydney)</p></li>
  143         -
    /// <li>
  144         -
    /// <p>Asia Pacific (Tokyo)</p></li>
  145         -
    /// <li>
  146         -
    /// <p>Europe (Ireland)</p></li>
  147         -
    /// <li>
  148         -
    /// <p>South America (São Paulo)</p></li>
  149         -
    /// </ul><note>
  150         -
    /// <p>This functionality is not supported for directory buckets.</p>
  151         -
    /// </note>
          47  +
    /// <p></p>
  152     48   
    pub fn get_display_name(&self) -> &::std::option::Option<::std::string::String> {
  153     49   
        &self.display_name
  154     50   
    }
  155     51   
    /// <p>Container for the ID of the owner.</p>
  156     52   
    pub fn id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
  157     53   
        self.id = ::std::option::Option::Some(input.into());
  158     54   
        self
  159     55   
    }
  160     56   
    /// <p>Container for the ID of the owner.</p>
  161     57   
    pub fn set_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {

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

@@ -1,1 +33,33 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3         -
/// <p>The PublicAccessBlock configuration that you want to apply to this Amazon S3 bucket. You can enable the configuration options in any combination. For more information about when Amazon S3 considers a bucket or object public, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status">The Meaning of "Public"</a> in the <i>Amazon S3 User Guide</i>.</p>
           3  +
/// <p>The PublicAccessBlock configuration that you want to apply to this Amazon S3 bucket. You can enable the configuration options in any combination. Bucket-level settings work alongside account-level settings (which may inherit from organization-level policies). For more information about when Amazon S3 considers a bucket or object public, see <a href="https://docs.aws.amazon.com/AmazonS3/latest/dev/access-control-block-public-access.html#access-control-block-public-access-policy-status">The Meaning of "Public"</a> in the <i>Amazon S3 User Guide</i>.</p>
    4      4   
#[non_exhaustive]
    5      5   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6      6   
pub struct PublicAccessBlockConfiguration {
    7      7   
    /// <p>Specifies whether Amazon S3 should block public access control lists (ACLs) for this bucket and objects in this bucket. Setting this element to <code>TRUE</code> causes the following behavior:</p>
    8      8   
    /// <ul>
    9      9   
    /// <li>
   10     10   
    /// <p>PUT Bucket ACL and PUT Object ACL calls fail if the specified ACL is public.</p></li>
   11     11   
    /// <li>
   12     12   
    /// <p>PUT Object calls fail if the request includes a public ACL.</p></li>
   13     13   
    /// <li>