Client Test

Client Test

rev. dfb5149b65b7bcc09edd15b8e071ad43b5ac5943 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_return_consumed_capacity.rs

@@ -1,1 +129,150 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
    3         -
/// When writing a match expression against `ReturnConsumedCapacity`, it is important to ensure
           2  +
/* ClientEnumGenerator.kt:234 */
           3  +
/// /* ClientEnumGenerator.kt:234 */When writing a match expression against `ReturnConsumedCapacity`, it is important to ensure
    4      4   
/// your code is forward-compatible. That is, if a match arm handles a case for a
    5      5   
/// feature that is supported by the service but has not been represented as an enum
    6      6   
/// variant in a current version of SDK, your code should continue to work when you
    7      7   
/// upgrade SDK to a future version in which the enum does include a variant for that
    8      8   
/// feature.
    9         -
///
   10         -
/// Here is an example of how you can make a match expression forward-compatible:
   11         -
///
   12         -
/// ```text
           9  +
/// /* ClientEnumGenerator.kt:244 */
          10  +
/// /* ClientEnumGenerator.kt:245 */Here is an example of how you can make a match expression forward-compatible:
          11  +
/// /* ClientEnumGenerator.kt:246 */
          12  +
/// /* ClientEnumGenerator.kt:247 */```text
          13  +
/* ClientEnumGenerator.kt:248 */
   13     14   
/// # let returnconsumedcapacity = unimplemented!();
          15  +
/* ClientEnumGenerator.kt:249 */
   14     16   
/// match returnconsumedcapacity {
          17  +
/* ClientEnumGenerator.kt:251 */
   15     18   
///     ReturnConsumedCapacity::Indexes => { /* ... */ },
          19  +
/* ClientEnumGenerator.kt:251 */
   16     20   
///     ReturnConsumedCapacity::None => { /* ... */ },
          21  +
/* ClientEnumGenerator.kt:251 */
   17     22   
///     ReturnConsumedCapacity::Total => { /* ... */ },
          23  +
/* ClientEnumGenerator.kt:253 */
   18     24   
///     other @ _ if other.as_str() == "NewFeature" => { /* handles a case for `NewFeature` */ },
          25  +
/* ClientEnumGenerator.kt:254 */
   19     26   
///     _ => { /* ... */ },
          27  +
/* ClientEnumGenerator.kt:255 */
   20     28   
/// }
   21         -
/// ```
   22         -
/// The above code demonstrates that when `returnconsumedcapacity` represents
          29  +
/// /* ClientEnumGenerator.kt:256 */```
          30  +
/// /* ClientEnumGenerator.kt:257 */The above code demonstrates that when `returnconsumedcapacity` represents
   23     31   
/// `NewFeature`, the execution path will lead to the second last match arm,
   24     32   
/// even though the enum does not contain a variant `ReturnConsumedCapacity::NewFeature`
   25     33   
/// in the current version of SDK. The reason is that the variable `other`,
   26     34   
/// created by the `@` operator, is bound to
   27     35   
/// `ReturnConsumedCapacity::Unknown(UnknownVariantValue("NewFeature".to_owned()))`
   28     36   
/// and calling `as_str` on it yields `"NewFeature"`.
   29     37   
/// This match expression is forward-compatible when executed with a newer
   30     38   
/// version of SDK where the variant `ReturnConsumedCapacity::NewFeature` is defined.
   31     39   
/// Specifically, when `returnconsumedcapacity` represents `NewFeature`,
   32     40   
/// the execution path will hit the second last match arm as before by virtue of
   33     41   
/// calling `as_str` on `ReturnConsumedCapacity::NewFeature` also yielding `"NewFeature"`.
   34         -
///
   35         -
/// Explicitly matching on the `Unknown` variant should
          42  +
/// /* ClientEnumGenerator.kt:273 */
          43  +
/// /* ClientEnumGenerator.kt:274 */Explicitly matching on the `Unknown` variant should
   36     44   
/// be avoided for two reasons:
   37     45   
/// - The inner data `UnknownVariantValue` is opaque, and no further information can be extracted.
   38     46   
/// - It might inadvertently shadow other intended match arms.
   39         -
///
   40         -
/// <p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
          47  +
/// /* ClientEnumGenerator.kt:282 */
          48  +
/// /* EnumGenerator.kt:156 */<p>Determines the level of detail about provisioned throughput consumption that is returned in the response:</p>
   41     49   
/// <ul>
   42     50   
/// <li>
   43     51   
/// <p>
   44     52   
/// <code>INDEXES</code> - The response includes the aggregate <code>ConsumedCapacity</code> for the operation, together with <code>ConsumedCapacity</code> for each table and secondary index that was accessed.</p>
   45     53   
/// <p>Note that some operations, such as <code>GetItem</code> and <code>BatchGetItem</code>, do not access any indexes at all.  In these cases, specifying <code>INDEXES</code> will only return <code>ConsumedCapacity</code> information for table(s).</p>
   46     54   
/// </li>
   47     55   
/// <li>
   48     56   
/// <p>
   49     57   
/// <code>TOTAL</code> - The response includes only the aggregate <code>ConsumedCapacity</code> for the operation.</p>
   50     58   
/// </li>
   51     59   
/// <li>
   52     60   
/// <p>
   53     61   
/// <code>NONE</code> - No <code>ConsumedCapacity</code> details are included in the response.</p>
   54     62   
/// </li>
   55     63   
/// </ul>
          64  +
/* RustType.kt:516 */
   56     65   
#[non_exhaustive]
          66  +
/* RustType.kt:516 */
   57     67   
#[derive(
   58     68   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::Ord, ::std::cmp::PartialEq, ::std::cmp::PartialOrd, ::std::fmt::Debug, ::std::hash::Hash,
   59     69   
)]
   60         -
pub enum ReturnConsumedCapacity {
   61         -
    #[allow(missing_docs)] // documentation missing in model
          70  +
pub /* EnumGenerator.kt:267 */ enum ReturnConsumedCapacity {
          71  +
    /* EnumGenerator.kt:154 */ #[allow(missing_docs)] // documentation missing in model
          72  +
    /* EnumGenerator.kt:143 */
   62     73   
    Indexes,
   63         -
    #[allow(missing_docs)] // documentation missing in model
          74  +
    /* EnumGenerator.kt:154 */ #[allow(missing_docs)] // documentation missing in model
          75  +
    /* EnumGenerator.kt:143 */
   64     76   
    None,
   65         -
    #[allow(missing_docs)] // documentation missing in model
          77  +
    /* EnumGenerator.kt:154 */ #[allow(missing_docs)] // documentation missing in model
          78  +
    /* EnumGenerator.kt:143 */
   66     79   
    Total,
   67         -
    /// `Unknown` contains new variants that have been added since this code was generated.
          80  +
    /// /* ClientEnumGenerator.kt:175 */`Unknown` contains new variants that have been added since this code was generated.
          81  +
    /* ClientEnumGenerator.kt:176 */
   68     82   
    #[deprecated(note = "Don't directly match on `Unknown`. See the docs on this enum for the correct way to handle unknown variants.")]
   69         -
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue),
          83  +
    /* ClientEnumGenerator.kt:179 */
          84  +
    Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue), /* EnumGenerator.kt:267 */
   70     85   
}
          86  +
/* ClientEnumGenerator.kt:42 */
   71     87   
impl ::std::convert::From<&str> for ReturnConsumedCapacity {
   72     88   
    fn from(s: &str) -> Self {
   73     89   
        match s {
   74     90   
            "INDEXES" => ReturnConsumedCapacity::Indexes,
   75     91   
            "NONE" => ReturnConsumedCapacity::None,
   76     92   
            "TOTAL" => ReturnConsumedCapacity::Total,
   77     93   
            other => ReturnConsumedCapacity::Unknown(crate::primitives::sealed_enum_unknown::UnknownVariantValue(other.to_owned())),
   78     94   
        }
   79     95   
    }
   80     96   
}
          97  +
/* ClientEnumGenerator.kt:68 */
   81     98   
impl ::std::str::FromStr for ReturnConsumedCapacity {
   82     99   
    type Err = ::std::convert::Infallible;
   83    100   
   84    101   
    fn from_str(s: &str) -> ::std::result::Result<Self, <Self as ::std::str::FromStr>::Err> {
   85    102   
        ::std::result::Result::Ok(ReturnConsumedCapacity::from(s))
   86    103   
    }
   87    104   
}
         105  +
/* EnumGenerator.kt:274 */
   88    106   
impl ReturnConsumedCapacity {
   89    107   
    /// Returns the `&str` value of the enum member.
   90    108   
    pub fn as_str(&self) -> &str {
   91    109   
        match self {
   92    110   
            ReturnConsumedCapacity::Indexes => "INDEXES",
   93    111   
            ReturnConsumedCapacity::None => "NONE",
   94    112   
            ReturnConsumedCapacity::Total => "TOTAL",
   95    113   
            ReturnConsumedCapacity::Unknown(value) => value.as_str(),
   96    114   
        }
   97    115   
    }
   98    116   
    /// Returns all the `&str` representations of the enum members.
   99    117   
    pub const fn values() -> &'static [&'static str] {
  100    118   
        &["INDEXES", "NONE", "TOTAL"]
  101    119   
    }
  102    120   
}
         121  +
/* EnumGenerator.kt:223 */
  103    122   
impl ::std::convert::AsRef<str> for ReturnConsumedCapacity {
  104    123   
    fn as_ref(&self) -> &str {
  105    124   
        self.as_str()
  106    125   
    }
  107    126   
}
         127  +
/* ClientEnumGenerator.kt:117 */
  108    128   
impl ReturnConsumedCapacity {
  109    129   
    /// Parses the enum value while disallowing unknown variants.
  110    130   
    ///
  111    131   
    /// Unknown variants will result in an error.
  112    132   
    pub fn try_parse(value: &str) -> ::std::result::Result<Self, crate::error::UnknownVariantError> {
  113    133   
        match Self::from(value) {
  114    134   
            #[allow(deprecated)]
  115    135   
            Self::Unknown(_) => ::std::result::Result::Err(crate::error::UnknownVariantError::new(value)),
  116    136   
            known => Ok(known),
  117    137   
        }
  118    138   
    }
  119    139   
}
         140  +
/* ClientEnumGenerator.kt:136 */
  120    141   
impl ::std::fmt::Display for ReturnConsumedCapacity {
  121    142   
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
  122    143   
        match self {
  123    144   
            ReturnConsumedCapacity::Indexes => write!(f, "INDEXES"),
  124    145   
            ReturnConsumedCapacity::None => write!(f, "NONE"),
  125    146   
            ReturnConsumedCapacity::Total => write!(f, "TOTAL"),
  126    147   
            ReturnConsumedCapacity::Unknown(value) => write!(f, "{}", value),
  127    148   
        }
  128    149   
    }
  129    150   
}

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_return_item_collection_metrics.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_return_value.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_return_values_on_condition_check_failure.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_s3_sse_algorithm.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_scalar_attribute_type.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_select.rs

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

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_source_table_details.rs

@@ -1,1 +300,439 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
    3         -
/// <p>Contains the details of the table when the backup was created.</p>
           2  +
/* StructureGenerator.kt:197 */
           3  +
/// /* StructureGenerator.kt:197 */<p>Contains the details of the table when the backup was created.</p>
           4  +
/* RustType.kt:516 */
    4      5   
#[non_exhaustive]
           6  +
/* RustType.kt:516 */
    5      7   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6         -
pub struct SourceTableDetails {
    7         -
    /// <p>The name of the table for which the backup was created.</p>
           8  +
pub /* StructureGenerator.kt:201 */ struct SourceTableDetails {
           9  +
    /// /* StructureGenerator.kt:231 */<p>The name of the table for which the backup was created.</p>
    8     10   
    pub table_name: ::std::string::String,
    9         -
    /// <p>Unique identifier for the table for which the backup was created.</p>
          11  +
    /// /* StructureGenerator.kt:231 */<p>Unique identifier for the table for which the backup was created.</p>
   10     12   
    pub table_id: ::std::string::String,
   11         -
    /// <p>ARN of the table for which backup was created.</p>
          13  +
    /// /* StructureGenerator.kt:231 */<p>ARN of the table for which backup was created.</p>
   12     14   
    pub table_arn: ::std::option::Option<::std::string::String>,
   13         -
    /// <p>Size of the table in bytes. Note that this is an approximate value.</p>
          15  +
    /// /* StructureGenerator.kt:231 */<p>Size of the table in bytes. Note that this is an approximate value.</p>
   14     16   
    pub table_size_bytes: i64,
   15         -
    /// <p>Schema of the table.</p>
          17  +
    /// /* StructureGenerator.kt:231 */<p>Schema of the table.</p>
   16     18   
    pub key_schema: ::std::vec::Vec<crate::types::KeySchemaElement>,
   17         -
    /// <p>Time when the source table was created.</p>
          19  +
    /// /* StructureGenerator.kt:231 */<p>Time when the source table was created.</p>
   18     20   
    pub table_creation_date_time: ::aws_smithy_types::DateTime,
   19         -
    /// <p>Read IOPs and Write IOPS on the table when the backup was created.</p>
          21  +
    /// /* StructureGenerator.kt:231 */<p>Read IOPs and Write IOPS on the table when the backup was created.</p>
   20     22   
    pub provisioned_throughput: crate::types::ProvisionedThroughput,
   21         -
    /// <p>Number of items in the table. Note that this is an approximate value.</p>
          23  +
    /// /* StructureGenerator.kt:231 */<p>Number of items in the table. Note that this is an approximate value.</p>
   22     24   
    pub item_count: ::std::option::Option<i64>,
   23         -
    /// <p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
          25  +
    /// /* StructureGenerator.kt:231 */<p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
   24     26   
    /// <ul>
   25     27   
    /// <li>
   26     28   
    /// <p><code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads.</p></li>
   27     29   
    /// <li>
   28     30   
    /// <p><code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads.</p></li>
   29     31   
    /// </ul>
   30     32   
    pub billing_mode: ::std::option::Option<crate::types::BillingMode>,
          33  +
    /* StructureGenerator.kt:201 */
   31     34   
}
          35  +
/* StructureGenerator.kt:135 */
   32     36   
impl SourceTableDetails {
   33         -
    /// <p>The name of the table for which the backup was created.</p>
          37  +
    /// /* StructureGenerator.kt:231 */<p>The name of the table for which the backup was created.</p>
          38  +
    /* StructureGenerator.kt:166 */
   34     39   
    pub fn table_name(&self) -> &str {
          40  +
        /* StructureGenerator.kt:171 */
   35     41   
        use std::ops::Deref;
   36     42   
        self.table_name.deref()
          43  +
        /* StructureGenerator.kt:166 */
   37     44   
    }
   38         -
    /// <p>Unique identifier for the table for which the backup was created.</p>
          45  +
    /// /* StructureGenerator.kt:231 */<p>Unique identifier for the table for which the backup was created.</p>
          46  +
    /* StructureGenerator.kt:166 */
   39     47   
    pub fn table_id(&self) -> &str {
          48  +
        /* StructureGenerator.kt:171 */
   40     49   
        use std::ops::Deref;
   41     50   
        self.table_id.deref()
          51  +
        /* StructureGenerator.kt:166 */
   42     52   
    }
   43         -
    /// <p>ARN of the table for which backup was created.</p>
          53  +
    /// /* StructureGenerator.kt:231 */<p>ARN of the table for which backup was created.</p>
          54  +
    /* StructureGenerator.kt:166 */
   44     55   
    pub fn table_arn(&self) -> ::std::option::Option<&str> {
          56  +
        /* StructureGenerator.kt:169 */
   45     57   
        self.table_arn.as_deref()
          58  +
        /* StructureGenerator.kt:166 */
   46     59   
    }
   47         -
    /// <p>Size of the table in bytes. Note that this is an approximate value.</p>
          60  +
    /// /* StructureGenerator.kt:231 */<p>Size of the table in bytes. Note that this is an approximate value.</p>
          61  +
    /* StructureGenerator.kt:166 */
   48     62   
    pub fn table_size_bytes(&self) -> i64 {
          63  +
        /* StructureGenerator.kt:168 */
   49     64   
        self.table_size_bytes
          65  +
        /* StructureGenerator.kt:166 */
   50     66   
    }
   51         -
    /// <p>Schema of the table.</p>
          67  +
    /// /* StructureGenerator.kt:231 */<p>Schema of the table.</p>
          68  +
    /* StructureGenerator.kt:166 */
   52     69   
    pub fn key_schema(&self) -> &[crate::types::KeySchemaElement] {
          70  +
        /* StructureGenerator.kt:171 */
   53     71   
        use std::ops::Deref;
   54     72   
        self.key_schema.deref()
          73  +
        /* StructureGenerator.kt:166 */
   55     74   
    }
   56         -
    /// <p>Time when the source table was created.</p>
          75  +
    /// /* StructureGenerator.kt:231 */<p>Time when the source table was created.</p>
          76  +
    /* StructureGenerator.kt:166 */
   57     77   
    pub fn table_creation_date_time(&self) -> &::aws_smithy_types::DateTime {
          78  +
        /* StructureGenerator.kt:172 */
   58     79   
        &self.table_creation_date_time
          80  +
        /* StructureGenerator.kt:166 */
   59     81   
    }
   60         -
    /// <p>Read IOPs and Write IOPS on the table when the backup was created.</p>
          82  +
    /// /* StructureGenerator.kt:231 */<p>Read IOPs and Write IOPS on the table when the backup was created.</p>
          83  +
    /* StructureGenerator.kt:166 */
   61     84   
    pub fn provisioned_throughput(&self) -> &crate::types::ProvisionedThroughput {
          85  +
        /* StructureGenerator.kt:172 */
   62     86   
        &self.provisioned_throughput
          87  +
        /* StructureGenerator.kt:166 */
   63     88   
    }
   64         -
    /// <p>Number of items in the table. Note that this is an approximate value.</p>
          89  +
    /// /* StructureGenerator.kt:231 */<p>Number of items in the table. Note that this is an approximate value.</p>
          90  +
    /* StructureGenerator.kt:166 */
   65     91   
    pub fn item_count(&self) -> ::std::option::Option<i64> {
          92  +
        /* StructureGenerator.kt:168 */
   66     93   
        self.item_count
          94  +
        /* StructureGenerator.kt:166 */
   67     95   
    }
   68         -
    /// <p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
          96  +
    /// /* StructureGenerator.kt:231 */<p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
   69     97   
    /// <ul>
   70     98   
    /// <li>
   71     99   
    /// <p><code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads.</p></li>
   72    100   
    /// <li>
   73    101   
    /// <p><code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads.</p></li>
   74    102   
    /// </ul>
         103  +
    /* StructureGenerator.kt:166 */
   75    104   
    pub fn billing_mode(&self) -> ::std::option::Option<&crate::types::BillingMode> {
         105  +
        /* StructureGenerator.kt:170 */
   76    106   
        self.billing_mode.as_ref()
         107  +
        /* StructureGenerator.kt:166 */
   77    108   
    }
         109  +
    /* StructureGenerator.kt:135 */
   78    110   
}
         111  +
/* ClientCodegenVisitor.kt:237 */
   79    112   
impl SourceTableDetails {
   80         -
    /// Creates a new builder-style object to manufacture [`SourceTableDetails`](crate::types::SourceTableDetails).
         113  +
    /// /* BuilderGenerator.kt:173 */Creates a new builder-style object to manufacture [`SourceTableDetails`](crate::types::SourceTableDetails).
         114  +
    /* BuilderGenerator.kt:175 */
   81    115   
    pub fn builder() -> crate::types::builders::SourceTableDetailsBuilder {
         116  +
        /* BuilderGenerator.kt:176 */
   82    117   
        crate::types::builders::SourceTableDetailsBuilder::default()
         118  +
        /* BuilderGenerator.kt:175 */
   83    119   
    }
         120  +
    /* ClientCodegenVisitor.kt:237 */
   84    121   
}
   85    122   
   86         -
/// A builder for [`SourceTableDetails`](crate::types::SourceTableDetails).
         123  +
/// /* BuilderGenerator.kt:342 */A builder for [`SourceTableDetails`](crate::types::SourceTableDetails).
         124  +
/* RustType.kt:516 */
   87    125   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         126  +
/* RustType.kt:516 */
   88    127   
#[non_exhaustive]
         128  +
/* BuilderGenerator.kt:345 */
   89    129   
pub struct SourceTableDetailsBuilder {
   90         -
    pub(crate) table_name: ::std::option::Option<::std::string::String>,
   91         -
    pub(crate) table_id: ::std::option::Option<::std::string::String>,
   92         -
    pub(crate) table_arn: ::std::option::Option<::std::string::String>,
   93         -
    pub(crate) table_size_bytes: ::std::option::Option<i64>,
   94         -
    pub(crate) key_schema: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>,
   95         -
    pub(crate) table_creation_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
   96         -
    pub(crate) provisioned_throughput: ::std::option::Option<crate::types::ProvisionedThroughput>,
   97         -
    pub(crate) item_count: ::std::option::Option<i64>,
   98         -
    pub(crate) billing_mode: ::std::option::Option<crate::types::BillingMode>,
         130  +
    /* BuilderGenerator.kt:275 */ pub(crate) table_name: ::std::option::Option<::std::string::String>,
         131  +
    /* BuilderGenerator.kt:275 */ pub(crate) table_id: ::std::option::Option<::std::string::String>,
         132  +
    /* BuilderGenerator.kt:275 */ pub(crate) table_arn: ::std::option::Option<::std::string::String>,
         133  +
    /* BuilderGenerator.kt:275 */ pub(crate) table_size_bytes: ::std::option::Option<i64>,
         134  +
    /* BuilderGenerator.kt:275 */ pub(crate) key_schema: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>,
         135  +
    /* BuilderGenerator.kt:275 */ pub(crate) table_creation_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
         136  +
    /* BuilderGenerator.kt:275 */ pub(crate) provisioned_throughput: ::std::option::Option<crate::types::ProvisionedThroughput>,
         137  +
    /* BuilderGenerator.kt:275 */ pub(crate) item_count: ::std::option::Option<i64>,
         138  +
    /* BuilderGenerator.kt:275 */ pub(crate) billing_mode: ::std::option::Option<crate::types::BillingMode>,
         139  +
    /* BuilderGenerator.kt:345 */
   99    140   
}
         141  +
/* BuilderGenerator.kt:355 */
  100    142   
impl SourceTableDetailsBuilder {
  101         -
    /// <p>The name of the table for which the backup was created.</p>
  102         -
    /// This field is required.
         143  +
    /// /* BuilderGenerator.kt:286 */<p>The name of the table for which the backup was created.</p>
         144  +
    /// /* BuilderGenerator.kt:288 */This field is required.
         145  +
    /* BuilderGenerator.kt:291 */
  103    146   
    pub fn table_name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         147  +
        /* BuilderGenerator.kt:292 */
  104    148   
        self.table_name = ::std::option::Option::Some(input.into());
         149  +
        /* BuilderGenerator.kt:293 */
  105    150   
        self
         151  +
        /* BuilderGenerator.kt:291 */
  106    152   
    }
  107         -
    /// <p>The name of the table for which the backup was created.</p>
         153  +
    /// /* BuilderGenerator.kt:312 */<p>The name of the table for which the backup was created.</p>
         154  +
    /* BuilderGenerator.kt:314 */
  108    155   
    pub fn set_table_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         156  +
        /* BuilderGenerator.kt:315 */
  109    157   
        self.table_name = input;
  110    158   
        self
         159  +
        /* BuilderGenerator.kt:314 */
  111    160   
    }
  112         -
    /// <p>The name of the table for which the backup was created.</p>
         161  +
    /// /* BuilderGenerator.kt:334 */<p>The name of the table for which the backup was created.</p>
         162  +
    /* BuilderGenerator.kt:336 */
  113    163   
    pub fn get_table_name(&self) -> &::std::option::Option<::std::string::String> {
         164  +
        /* BuilderGenerator.kt:337 */
  114    165   
        &self.table_name
         166  +
        /* BuilderGenerator.kt:336 */
  115    167   
    }
  116         -
    /// <p>Unique identifier for the table for which the backup was created.</p>
  117         -
    /// This field is required.
         168  +
    /// /* BuilderGenerator.kt:286 */<p>Unique identifier for the table for which the backup was created.</p>
         169  +
    /// /* BuilderGenerator.kt:288 */This field is required.
         170  +
    /* BuilderGenerator.kt:291 */
  118    171   
    pub fn table_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         172  +
        /* BuilderGenerator.kt:292 */
  119    173   
        self.table_id = ::std::option::Option::Some(input.into());
         174  +
        /* BuilderGenerator.kt:293 */
  120    175   
        self
         176  +
        /* BuilderGenerator.kt:291 */
  121    177   
    }
  122         -
    /// <p>Unique identifier for the table for which the backup was created.</p>
         178  +
    /// /* BuilderGenerator.kt:312 */<p>Unique identifier for the table for which the backup was created.</p>
         179  +
    /* BuilderGenerator.kt:314 */
  123    180   
    pub fn set_table_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         181  +
        /* BuilderGenerator.kt:315 */
  124    182   
        self.table_id = input;
  125    183   
        self
         184  +
        /* BuilderGenerator.kt:314 */
  126    185   
    }
  127         -
    /// <p>Unique identifier for the table for which the backup was created.</p>
         186  +
    /// /* BuilderGenerator.kt:334 */<p>Unique identifier for the table for which the backup was created.</p>
         187  +
    /* BuilderGenerator.kt:336 */
  128    188   
    pub fn get_table_id(&self) -> &::std::option::Option<::std::string::String> {
         189  +
        /* BuilderGenerator.kt:337 */
  129    190   
        &self.table_id
         191  +
        /* BuilderGenerator.kt:336 */
  130    192   
    }
  131         -
    /// <p>ARN of the table for which backup was created.</p>
         193  +
    /// /* BuilderGenerator.kt:286 */<p>ARN of the table for which backup was created.</p>
         194  +
    /* BuilderGenerator.kt:291 */
  132    195   
    pub fn table_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         196  +
        /* BuilderGenerator.kt:292 */
  133    197   
        self.table_arn = ::std::option::Option::Some(input.into());
         198  +
        /* BuilderGenerator.kt:293 */
  134    199   
        self
         200  +
        /* BuilderGenerator.kt:291 */
  135    201   
    }
  136         -
    /// <p>ARN of the table for which backup was created.</p>
         202  +
    /// /* BuilderGenerator.kt:312 */<p>ARN of the table for which backup was created.</p>
         203  +
    /* BuilderGenerator.kt:314 */
  137    204   
    pub fn set_table_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         205  +
        /* BuilderGenerator.kt:315 */
  138    206   
        self.table_arn = input;
  139    207   
        self
         208  +
        /* BuilderGenerator.kt:314 */
  140    209   
    }
  141         -
    /// <p>ARN of the table for which backup was created.</p>
         210  +
    /// /* BuilderGenerator.kt:334 */<p>ARN of the table for which backup was created.</p>
         211  +
    /* BuilderGenerator.kt:336 */
  142    212   
    pub fn get_table_arn(&self) -> &::std::option::Option<::std::string::String> {
         213  +
        /* BuilderGenerator.kt:337 */
  143    214   
        &self.table_arn
         215  +
        /* BuilderGenerator.kt:336 */
  144    216   
    }
  145         -
    /// <p>Size of the table in bytes. Note that this is an approximate value.</p>
         217  +
    /// /* BuilderGenerator.kt:286 */<p>Size of the table in bytes. Note that this is an approximate value.</p>
         218  +
    /* BuilderGenerator.kt:291 */
  146    219   
    pub fn table_size_bytes(mut self, input: i64) -> Self {
         220  +
        /* BuilderGenerator.kt:292 */
  147    221   
        self.table_size_bytes = ::std::option::Option::Some(input);
         222  +
        /* BuilderGenerator.kt:293 */
  148    223   
        self
         224  +
        /* BuilderGenerator.kt:291 */
  149    225   
    }
  150         -
    /// <p>Size of the table in bytes. Note that this is an approximate value.</p>
         226  +
    /// /* BuilderGenerator.kt:312 */<p>Size of the table in bytes. Note that this is an approximate value.</p>
         227  +
    /* BuilderGenerator.kt:314 */
  151    228   
    pub fn set_table_size_bytes(mut self, input: ::std::option::Option<i64>) -> Self {
         229  +
        /* BuilderGenerator.kt:315 */
  152    230   
        self.table_size_bytes = input;
  153    231   
        self
         232  +
        /* BuilderGenerator.kt:314 */
  154    233   
    }
  155         -
    /// <p>Size of the table in bytes. Note that this is an approximate value.</p>
         234  +
    /// /* BuilderGenerator.kt:334 */<p>Size of the table in bytes. Note that this is an approximate value.</p>
         235  +
    /* BuilderGenerator.kt:336 */
  156    236   
    pub fn get_table_size_bytes(&self) -> &::std::option::Option<i64> {
         237  +
        /* BuilderGenerator.kt:337 */
  157    238   
        &self.table_size_bytes
         239  +
        /* BuilderGenerator.kt:336 */
  158    240   
    }
  159         -
    /// Appends an item to `key_schema`.
         241  +
    /// /* BuilderGenerator.kt:410 */Appends an item to `key_schema`.
         242  +
    /* BuilderGenerator.kt:411 */
  160    243   
    ///
  161         -
    /// To override the contents of this collection use [`set_key_schema`](Self::set_key_schema).
         244  +
    /// /* BuilderGenerator.kt:412 */To override the contents of this collection use [`set_key_schema`](Self::set_key_schema).
         245  +
    /* BuilderGenerator.kt:413 */
  162    246   
    ///
  163         -
    /// <p>Schema of the table.</p>
         247  +
    /// /* BuilderGenerator.kt:414 */<p>Schema of the table.</p>
         248  +
    /* BuilderGenerator.kt:418 */
  164    249   
    pub fn key_schema(mut self, input: crate::types::KeySchemaElement) -> Self {
         250  +
        /* BuilderGenerator.kt:419 */
  165    251   
        let mut v = self.key_schema.unwrap_or_default();
  166    252   
        v.push(input);
  167    253   
        self.key_schema = ::std::option::Option::Some(v);
  168    254   
        self
         255  +
        /* BuilderGenerator.kt:418 */
  169    256   
    }
  170         -
    /// <p>Schema of the table.</p>
         257  +
    /// /* BuilderGenerator.kt:312 */<p>Schema of the table.</p>
         258  +
    /* BuilderGenerator.kt:314 */
  171    259   
    pub fn set_key_schema(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>>) -> Self {
         260  +
        /* BuilderGenerator.kt:315 */
  172    261   
        self.key_schema = input;
  173    262   
        self
         263  +
        /* BuilderGenerator.kt:314 */
  174    264   
    }
  175         -
    /// <p>Schema of the table.</p>
         265  +
    /// /* BuilderGenerator.kt:334 */<p>Schema of the table.</p>
         266  +
    /* BuilderGenerator.kt:336 */
  176    267   
    pub fn get_key_schema(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::KeySchemaElement>> {
         268  +
        /* BuilderGenerator.kt:337 */
  177    269   
        &self.key_schema
         270  +
        /* BuilderGenerator.kt:336 */
  178    271   
    }
  179         -
    /// <p>Time when the source table was created.</p>
  180         -
    /// This field is required.
         272  +
    /// /* BuilderGenerator.kt:286 */<p>Time when the source table was created.</p>
         273  +
    /// /* BuilderGenerator.kt:288 */This field is required.
         274  +
    /* BuilderGenerator.kt:291 */
  181    275   
    pub fn table_creation_date_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         276  +
        /* BuilderGenerator.kt:292 */
  182    277   
        self.table_creation_date_time = ::std::option::Option::Some(input);
         278  +
        /* BuilderGenerator.kt:293 */
  183    279   
        self
         280  +
        /* BuilderGenerator.kt:291 */
  184    281   
    }
  185         -
    /// <p>Time when the source table was created.</p>
         282  +
    /// /* BuilderGenerator.kt:312 */<p>Time when the source table was created.</p>
         283  +
    /* BuilderGenerator.kt:314 */
  186    284   
    pub fn set_table_creation_date_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         285  +
        /* BuilderGenerator.kt:315 */
  187    286   
        self.table_creation_date_time = input;
  188    287   
        self
         288  +
        /* BuilderGenerator.kt:314 */
  189    289   
    }
  190         -
    /// <p>Time when the source table was created.</p>
         290  +
    /// /* BuilderGenerator.kt:334 */<p>Time when the source table was created.</p>
         291  +
    /* BuilderGenerator.kt:336 */
  191    292   
    pub fn get_table_creation_date_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         293  +
        /* BuilderGenerator.kt:337 */
  192    294   
        &self.table_creation_date_time
         295  +
        /* BuilderGenerator.kt:336 */
  193    296   
    }
  194         -
    /// <p>Read IOPs and Write IOPS on the table when the backup was created.</p>
  195         -
    /// This field is required.
         297  +
    /// /* BuilderGenerator.kt:286 */<p>Read IOPs and Write IOPS on the table when the backup was created.</p>
         298  +
    /// /* BuilderGenerator.kt:288 */This field is required.
         299  +
    /* BuilderGenerator.kt:291 */
  196    300   
    pub fn provisioned_throughput(mut self, input: crate::types::ProvisionedThroughput) -> Self {
         301  +
        /* BuilderGenerator.kt:292 */
  197    302   
        self.provisioned_throughput = ::std::option::Option::Some(input);
         303  +
        /* BuilderGenerator.kt:293 */
  198    304   
        self
         305  +
        /* BuilderGenerator.kt:291 */
  199    306   
    }
  200         -
    /// <p>Read IOPs and Write IOPS on the table when the backup was created.</p>
         307  +
    /// /* BuilderGenerator.kt:312 */<p>Read IOPs and Write IOPS on the table when the backup was created.</p>
         308  +
    /* BuilderGenerator.kt:314 */
  201    309   
    pub fn set_provisioned_throughput(mut self, input: ::std::option::Option<crate::types::ProvisionedThroughput>) -> Self {
         310  +
        /* BuilderGenerator.kt:315 */
  202    311   
        self.provisioned_throughput = input;
  203    312   
        self
         313  +
        /* BuilderGenerator.kt:314 */
  204    314   
    }
  205         -
    /// <p>Read IOPs and Write IOPS on the table when the backup was created.</p>
         315  +
    /// /* BuilderGenerator.kt:334 */<p>Read IOPs and Write IOPS on the table when the backup was created.</p>
         316  +
    /* BuilderGenerator.kt:336 */
  206    317   
    pub fn get_provisioned_throughput(&self) -> &::std::option::Option<crate::types::ProvisionedThroughput> {
         318  +
        /* BuilderGenerator.kt:337 */
  207    319   
        &self.provisioned_throughput
         320  +
        /* BuilderGenerator.kt:336 */
  208    321   
    }
  209         -
    /// <p>Number of items in the table. Note that this is an approximate value.</p>
         322  +
    /// /* BuilderGenerator.kt:286 */<p>Number of items in the table. Note that this is an approximate value.</p>
         323  +
    /* BuilderGenerator.kt:291 */
  210    324   
    pub fn item_count(mut self, input: i64) -> Self {
         325  +
        /* BuilderGenerator.kt:292 */
  211    326   
        self.item_count = ::std::option::Option::Some(input);
         327  +
        /* BuilderGenerator.kt:293 */
  212    328   
        self
         329  +
        /* BuilderGenerator.kt:291 */
  213    330   
    }
  214         -
    /// <p>Number of items in the table. Note that this is an approximate value.</p>
         331  +
    /// /* BuilderGenerator.kt:312 */<p>Number of items in the table. Note that this is an approximate value.</p>
         332  +
    /* BuilderGenerator.kt:314 */
  215    333   
    pub fn set_item_count(mut self, input: ::std::option::Option<i64>) -> Self {
         334  +
        /* BuilderGenerator.kt:315 */
  216    335   
        self.item_count = input;
  217    336   
        self
         337  +
        /* BuilderGenerator.kt:314 */
  218    338   
    }
  219         -
    /// <p>Number of items in the table. Note that this is an approximate value.</p>
         339  +
    /// /* BuilderGenerator.kt:334 */<p>Number of items in the table. Note that this is an approximate value.</p>
         340  +
    /* BuilderGenerator.kt:336 */
  220    341   
    pub fn get_item_count(&self) -> &::std::option::Option<i64> {
         342  +
        /* BuilderGenerator.kt:337 */
  221    343   
        &self.item_count
         344  +
        /* BuilderGenerator.kt:336 */
  222    345   
    }
  223         -
    /// <p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
         346  +
    /// /* BuilderGenerator.kt:286 */<p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
  224    347   
    /// <ul>
  225    348   
    /// <li>
  226    349   
    /// <p><code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads.</p></li>
  227    350   
    /// <li>
  228    351   
    /// <p><code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads.</p></li>
  229    352   
    /// </ul>
         353  +
    /* BuilderGenerator.kt:291 */
  230    354   
    pub fn billing_mode(mut self, input: crate::types::BillingMode) -> Self {
         355  +
        /* BuilderGenerator.kt:292 */
  231    356   
        self.billing_mode = ::std::option::Option::Some(input);
         357  +
        /* BuilderGenerator.kt:293 */
  232    358   
        self
         359  +
        /* BuilderGenerator.kt:291 */
  233    360   
    }
  234         -
    /// <p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
         361  +
    /// /* BuilderGenerator.kt:312 */<p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
  235    362   
    /// <ul>
  236    363   
    /// <li>
  237    364   
    /// <p><code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads.</p></li>
  238    365   
    /// <li>
  239    366   
    /// <p><code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads.</p></li>
  240    367   
    /// </ul>
         368  +
    /* BuilderGenerator.kt:314 */
  241    369   
    pub fn set_billing_mode(mut self, input: ::std::option::Option<crate::types::BillingMode>) -> Self {
         370  +
        /* BuilderGenerator.kt:315 */
  242    371   
        self.billing_mode = input;
  243    372   
        self
         373  +
        /* BuilderGenerator.kt:314 */
  244    374   
    }
  245         -
    /// <p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
         375  +
    /// /* BuilderGenerator.kt:334 */<p>Controls how you are charged for read and write throughput and how you manage capacity. This setting can be changed later.</p>
  246    376   
    /// <ul>
  247    377   
    /// <li>
  248    378   
    /// <p><code>PROVISIONED</code> - Sets the read/write capacity mode to <code>PROVISIONED</code>. We recommend using <code>PROVISIONED</code> for predictable workloads.</p></li>
  249    379   
    /// <li>
  250    380   
    /// <p><code>PAY_PER_REQUEST</code> - Sets the read/write capacity mode to <code>PAY_PER_REQUEST</code>. We recommend using <code>PAY_PER_REQUEST</code> for unpredictable workloads.</p></li>
  251    381   
    /// </ul>
         382  +
    /* BuilderGenerator.kt:336 */
  252    383   
    pub fn get_billing_mode(&self) -> &::std::option::Option<crate::types::BillingMode> {
         384  +
        /* BuilderGenerator.kt:337 */
  253    385   
        &self.billing_mode
  254         -
    }
  255         -
    /// Consumes the builder and constructs a [`SourceTableDetails`](crate::types::SourceTableDetails).
  256         -
    /// This method will fail if any of the following fields are not set:
  257         -
    /// - [`table_name`](crate::types::builders::SourceTableDetailsBuilder::table_name)
  258         -
    /// - [`table_id`](crate::types::builders::SourceTableDetailsBuilder::table_id)
  259         -
    /// - [`key_schema`](crate::types::builders::SourceTableDetailsBuilder::key_schema)
  260         -
    /// - [`table_creation_date_time`](crate::types::builders::SourceTableDetailsBuilder::table_creation_date_time)
  261         -
    /// - [`provisioned_throughput`](crate::types::builders::SourceTableDetailsBuilder::provisioned_throughput)
         386  +
        /* BuilderGenerator.kt:336 */
         387  +
    }
         388  +
    /// /* BuilderGenerator.kt:240 */Consumes the builder and constructs a [`SourceTableDetails`](crate::types::SourceTableDetails).
         389  +
    /// /* BuilderGenerator.kt:243 */This method will fail if any of the following fields are not set:
         390  +
    /// /* BuilderGenerator.kt:246 */- [`table_name`](crate::types::builders::SourceTableDetailsBuilder::table_name)
         391  +
    /// /* BuilderGenerator.kt:246 */- [`table_id`](crate::types::builders::SourceTableDetailsBuilder::table_id)
         392  +
    /// /* BuilderGenerator.kt:246 */- [`key_schema`](crate::types::builders::SourceTableDetailsBuilder::key_schema)
         393  +
    /// /* BuilderGenerator.kt:246 */- [`table_creation_date_time`](crate::types::builders::SourceTableDetailsBuilder::table_creation_date_time)
         394  +
    /// /* BuilderGenerator.kt:246 */- [`provisioned_throughput`](crate::types::builders::SourceTableDetailsBuilder::provisioned_throughput)
         395  +
    /* BuilderGenerator.kt:253 */
  262    396   
    pub fn build(self) -> ::std::result::Result<crate::types::SourceTableDetails, ::aws_smithy_types::error::operation::BuildError> {
  263         -
        ::std::result::Result::Ok(crate::types::SourceTableDetails {
  264         -
            table_name: self.table_name.ok_or_else(|| {
  265         -
                ::aws_smithy_types::error::operation::BuildError::missing_field(
  266         -
                    "table_name",
  267         -
                    "table_name was not specified but it is required when building SourceTableDetails",
  268         -
                )
  269         -
            })?,
  270         -
            table_id: self.table_id.ok_or_else(|| {
  271         -
                ::aws_smithy_types::error::operation::BuildError::missing_field(
  272         -
                    "table_id",
  273         -
                    "table_id was not specified but it is required when building SourceTableDetails",
  274         -
                )
  275         -
            })?,
  276         -
            table_arn: self.table_arn,
  277         -
            table_size_bytes: self.table_size_bytes.unwrap_or_default(),
  278         -
            key_schema: self.key_schema.ok_or_else(|| {
  279         -
                ::aws_smithy_types::error::operation::BuildError::missing_field(
  280         -
                    "key_schema",
  281         -
                    "key_schema was not specified but it is required when building SourceTableDetails",
  282         -
                )
  283         -
            })?,
  284         -
            table_creation_date_time: self.table_creation_date_time.ok_or_else(|| {
  285         -
                ::aws_smithy_types::error::operation::BuildError::missing_field(
  286         -
                    "table_creation_date_time",
  287         -
                    "table_creation_date_time was not specified but it is required when building SourceTableDetails",
  288         -
                )
  289         -
            })?,
  290         -
            provisioned_throughput: self.provisioned_throughput.ok_or_else(|| {
  291         -
                ::aws_smithy_types::error::operation::BuildError::missing_field(
  292         -
                    "provisioned_throughput",
  293         -
                    "provisioned_throughput was not specified but it is required when building SourceTableDetails",
  294         -
                )
  295         -
            })?,
  296         -
            item_count: self.item_count,
  297         -
            billing_mode: self.billing_mode,
  298         -
        })
  299         -
    }
         397  +
        /* BuilderGenerator.kt:254 */
         398  +
        ::std::result::Result::Ok(
         399  +
            /* BuilderGenerator.kt:477 */crate::types::SourceTableDetails {
         400  +
                /* BuilderGenerator.kt:481 */table_name: self.table_name
         401  +
                    /* BuilderGenerator.kt:494 */.ok_or_else(||
         402  +
                        /* BuilderGenerator.kt:117 */::aws_smithy_types::error::operation::BuildError::missing_field("table_name", "table_name was not specified but it is required when building SourceTableDetails")
         403  +
                    /* BuilderGenerator.kt:494 */)?
         404  +
                ,
         405  +
                /* BuilderGenerator.kt:481 */table_id: self.table_id
         406  +
                    /* BuilderGenerator.kt:494 */.ok_or_else(||
         407  +
                        /* BuilderGenerator.kt:117 */::aws_smithy_types::error::operation::BuildError::missing_field("table_id", "table_id was not specified but it is required when building SourceTableDetails")
         408  +
                    /* BuilderGenerator.kt:494 */)?
         409  +
                ,
         410  +
                /* BuilderGenerator.kt:481 */table_arn: self.table_arn
         411  +
                ,
         412  +
                /* BuilderGenerator.kt:481 */table_size_bytes: self.table_size_bytes
         413  +
                    /* BuilderGenerator.kt:487 */.unwrap_or_default()
         414  +
                ,
         415  +
                /* BuilderGenerator.kt:481 */key_schema: self.key_schema
         416  +
                    /* BuilderGenerator.kt:494 */.ok_or_else(||
         417  +
                        /* BuilderGenerator.kt:117 */::aws_smithy_types::error::operation::BuildError::missing_field("key_schema", "key_schema was not specified but it is required when building SourceTableDetails")
         418  +
                    /* BuilderGenerator.kt:494 */)?
         419  +
                ,
         420  +
                /* BuilderGenerator.kt:481 */table_creation_date_time: self.table_creation_date_time
         421  +
                    /* BuilderGenerator.kt:494 */.ok_or_else(||
         422  +
                        /* BuilderGenerator.kt:117 */::aws_smithy_types::error::operation::BuildError::missing_field("table_creation_date_time", "table_creation_date_time was not specified but it is required when building SourceTableDetails")
         423  +
                    /* BuilderGenerator.kt:494 */)?
         424  +
                ,
         425  +
                /* BuilderGenerator.kt:481 */provisioned_throughput: self.provisioned_throughput
         426  +
                    /* BuilderGenerator.kt:494 */.ok_or_else(||
         427  +
                        /* BuilderGenerator.kt:117 */::aws_smithy_types::error::operation::BuildError::missing_field("provisioned_throughput", "provisioned_throughput was not specified but it is required when building SourceTableDetails")
         428  +
                    /* BuilderGenerator.kt:494 */)?
         429  +
                ,
         430  +
                /* BuilderGenerator.kt:481 */item_count: self.item_count
         431  +
                ,
         432  +
                /* BuilderGenerator.kt:481 */billing_mode: self.billing_mode
         433  +
                ,
         434  +
            /* BuilderGenerator.kt:477 */}
         435  +
        /* BuilderGenerator.kt:254 */)
         436  +
        /* BuilderGenerator.kt:253 */
         437  +
    }
         438  +
    /* BuilderGenerator.kt:355 */
  300    439   
}

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_source_table_feature_details.rs

@@ -1,1 +154,254 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
    3         -
/// <p>Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL.</p>
           2  +
/* StructureGenerator.kt:197 */
           3  +
/// /* StructureGenerator.kt:197 */<p>Contains the details of the features enabled on the table when the backup was created. For example, LSIs, GSIs, streams, TTL.</p>
           4  +
/* RustType.kt:516 */
    4      5   
#[non_exhaustive]
           6  +
/* RustType.kt:516 */
    5      7   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6         -
pub struct SourceTableFeatureDetails {
    7         -
    /// <p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
           8  +
pub /* StructureGenerator.kt:201 */ struct SourceTableFeatureDetails {
           9  +
    /// /* StructureGenerator.kt:231 */<p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
    8     10   
    pub local_secondary_indexes: ::std::option::Option<::std::vec::Vec<crate::types::LocalSecondaryIndexInfo>>,
    9         -
    /// <p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
          11  +
    /// /* StructureGenerator.kt:231 */<p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
   10     12   
    pub global_secondary_indexes: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexInfo>>,
   11         -
    /// <p>Stream settings on the table when the backup was created.</p>
          13  +
    /// /* StructureGenerator.kt:231 */<p>Stream settings on the table when the backup was created.</p>
   12     14   
    pub stream_description: ::std::option::Option<crate::types::StreamSpecification>,
   13         -
    /// <p>Time to Live settings on the table when the backup was created.</p>
          15  +
    /// /* StructureGenerator.kt:231 */<p>Time to Live settings on the table when the backup was created.</p>
   14     16   
    pub time_to_live_description: ::std::option::Option<crate::types::TimeToLiveDescription>,
   15         -
    /// <p>The description of the server-side encryption status on the table when the backup was created.</p>
          17  +
    /// /* StructureGenerator.kt:231 */<p>The description of the server-side encryption status on the table when the backup was created.</p>
   16     18   
    pub sse_description: ::std::option::Option<crate::types::SseDescription>,
          19  +
    /* StructureGenerator.kt:201 */
   17     20   
}
          21  +
/* StructureGenerator.kt:135 */
   18     22   
impl SourceTableFeatureDetails {
   19         -
    /// <p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
   20         -
    ///
   21         -
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.local_secondary_indexes.is_none()`.
          23  +
    /// /* StructureGenerator.kt:231 */<p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
          24  +
    /// /* StructureGenerator.kt:162 */
          25  +
    /// /* StructureGenerator.kt:163 */If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.local_secondary_indexes.is_none()`.
          26  +
    /* StructureGenerator.kt:166 */
   22     27   
    pub fn local_secondary_indexes(&self) -> &[crate::types::LocalSecondaryIndexInfo] {
   23         -
        self.local_secondary_indexes.as_deref().unwrap_or_default()
   24         -
    }
   25         -
    /// <p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
   26         -
    ///
   27         -
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.global_secondary_indexes.is_none()`.
          28  +
        /* StructureGenerator.kt:169 */
          29  +
        self.local_secondary_indexes
          30  +
            .as_deref()
          31  +
            /* StructureGenerator.kt:175 */
          32  +
            .unwrap_or_default()
          33  +
        /* StructureGenerator.kt:166 */
          34  +
    }
          35  +
    /// /* StructureGenerator.kt:231 */<p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
          36  +
    /// /* StructureGenerator.kt:162 */
          37  +
    /// /* StructureGenerator.kt:163 */If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.global_secondary_indexes.is_none()`.
          38  +
    /* StructureGenerator.kt:166 */
   28     39   
    pub fn global_secondary_indexes(&self) -> &[crate::types::GlobalSecondaryIndexInfo] {
   29         -
        self.global_secondary_indexes.as_deref().unwrap_or_default()
   30         -
    }
   31         -
    /// <p>Stream settings on the table when the backup was created.</p>
          40  +
        /* StructureGenerator.kt:169 */
          41  +
        self.global_secondary_indexes
          42  +
            .as_deref()
          43  +
            /* StructureGenerator.kt:175 */
          44  +
            .unwrap_or_default()
          45  +
        /* StructureGenerator.kt:166 */
          46  +
    }
          47  +
    /// /* StructureGenerator.kt:231 */<p>Stream settings on the table when the backup was created.</p>
          48  +
    /* StructureGenerator.kt:166 */
   32     49   
    pub fn stream_description(&self) -> ::std::option::Option<&crate::types::StreamSpecification> {
          50  +
        /* StructureGenerator.kt:170 */
   33     51   
        self.stream_description.as_ref()
          52  +
        /* StructureGenerator.kt:166 */
   34     53   
    }
   35         -
    /// <p>Time to Live settings on the table when the backup was created.</p>
          54  +
    /// /* StructureGenerator.kt:231 */<p>Time to Live settings on the table when the backup was created.</p>
          55  +
    /* StructureGenerator.kt:166 */
   36     56   
    pub fn time_to_live_description(&self) -> ::std::option::Option<&crate::types::TimeToLiveDescription> {
          57  +
        /* StructureGenerator.kt:170 */
   37     58   
        self.time_to_live_description.as_ref()
          59  +
        /* StructureGenerator.kt:166 */
   38     60   
    }
   39         -
    /// <p>The description of the server-side encryption status on the table when the backup was created.</p>
          61  +
    /// /* StructureGenerator.kt:231 */<p>The description of the server-side encryption status on the table when the backup was created.</p>
          62  +
    /* StructureGenerator.kt:166 */
   40     63   
    pub fn sse_description(&self) -> ::std::option::Option<&crate::types::SseDescription> {
          64  +
        /* StructureGenerator.kt:170 */
   41     65   
        self.sse_description.as_ref()
          66  +
        /* StructureGenerator.kt:166 */
   42     67   
    }
          68  +
    /* StructureGenerator.kt:135 */
   43     69   
}
          70  +
/* ClientCodegenVisitor.kt:237 */
   44     71   
impl SourceTableFeatureDetails {
   45         -
    /// Creates a new builder-style object to manufacture [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
          72  +
    /// /* BuilderGenerator.kt:173 */Creates a new builder-style object to manufacture [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
          73  +
    /* BuilderGenerator.kt:175 */
   46     74   
    pub fn builder() -> crate::types::builders::SourceTableFeatureDetailsBuilder {
          75  +
        /* BuilderGenerator.kt:176 */
   47     76   
        crate::types::builders::SourceTableFeatureDetailsBuilder::default()
          77  +
        /* BuilderGenerator.kt:175 */
   48     78   
    }
          79  +
    /* ClientCodegenVisitor.kt:237 */
   49     80   
}
   50     81   
   51         -
/// A builder for [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
          82  +
/// /* BuilderGenerator.kt:342 */A builder for [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
          83  +
/* RustType.kt:516 */
   52     84   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
          85  +
/* RustType.kt:516 */
   53     86   
#[non_exhaustive]
          87  +
/* BuilderGenerator.kt:345 */
   54     88   
pub struct SourceTableFeatureDetailsBuilder {
          89  +
    /* BuilderGenerator.kt:275 */
   55     90   
    pub(crate) local_secondary_indexes: ::std::option::Option<::std::vec::Vec<crate::types::LocalSecondaryIndexInfo>>,
          91  +
    /* BuilderGenerator.kt:275 */
   56     92   
    pub(crate) global_secondary_indexes: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexInfo>>,
   57         -
    pub(crate) stream_description: ::std::option::Option<crate::types::StreamSpecification>,
   58         -
    pub(crate) time_to_live_description: ::std::option::Option<crate::types::TimeToLiveDescription>,
          93  +
    /* BuilderGenerator.kt:275 */ pub(crate) stream_description: ::std::option::Option<crate::types::StreamSpecification>,
          94  +
    /* BuilderGenerator.kt:275 */ pub(crate) time_to_live_description: ::std::option::Option<crate::types::TimeToLiveDescription>,
          95  +
    /* BuilderGenerator.kt:275 */
   59     96   
    pub(crate) sse_description: ::std::option::Option<crate::types::SseDescription>,
          97  +
    /* BuilderGenerator.kt:345 */
   60     98   
}
          99  +
/* BuilderGenerator.kt:355 */
   61    100   
impl SourceTableFeatureDetailsBuilder {
   62         -
    /// Appends an item to `local_secondary_indexes`.
         101  +
    /// /* BuilderGenerator.kt:410 */Appends an item to `local_secondary_indexes`.
         102  +
    /* BuilderGenerator.kt:411 */
   63    103   
    ///
   64         -
    /// To override the contents of this collection use [`set_local_secondary_indexes`](Self::set_local_secondary_indexes).
         104  +
    /// /* BuilderGenerator.kt:412 */To override the contents of this collection use [`set_local_secondary_indexes`](Self::set_local_secondary_indexes).
         105  +
    /* BuilderGenerator.kt:413 */
   65    106   
    ///
   66         -
    /// <p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         107  +
    /// /* BuilderGenerator.kt:414 */<p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         108  +
    /* BuilderGenerator.kt:418 */
   67    109   
    pub fn local_secondary_indexes(mut self, input: crate::types::LocalSecondaryIndexInfo) -> Self {
         110  +
        /* BuilderGenerator.kt:419 */
   68    111   
        let mut v = self.local_secondary_indexes.unwrap_or_default();
   69    112   
        v.push(input);
   70    113   
        self.local_secondary_indexes = ::std::option::Option::Some(v);
   71    114   
        self
         115  +
        /* BuilderGenerator.kt:418 */
   72    116   
    }
   73         -
    /// <p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         117  +
    /// /* BuilderGenerator.kt:312 */<p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         118  +
    /* BuilderGenerator.kt:314 */
   74    119   
    pub fn set_local_secondary_indexes(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::LocalSecondaryIndexInfo>>) -> Self {
         120  +
        /* BuilderGenerator.kt:315 */
   75    121   
        self.local_secondary_indexes = input;
   76    122   
        self
         123  +
        /* BuilderGenerator.kt:314 */
   77    124   
    }
   78         -
    /// <p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         125  +
    /// /* BuilderGenerator.kt:334 */<p>Represents the LSI properties for the table when the backup was created. It includes the IndexName, KeySchema and Projection for the LSIs on the table at the time of backup.</p>
         126  +
    /* BuilderGenerator.kt:336 */
   79    127   
    pub fn get_local_secondary_indexes(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::LocalSecondaryIndexInfo>> {
         128  +
        /* BuilderGenerator.kt:337 */
   80    129   
        &self.local_secondary_indexes
         130  +
        /* BuilderGenerator.kt:336 */
   81    131   
    }
   82         -
    /// Appends an item to `global_secondary_indexes`.
         132  +
    /// /* BuilderGenerator.kt:410 */Appends an item to `global_secondary_indexes`.
         133  +
    /* BuilderGenerator.kt:411 */
   83    134   
    ///
   84         -
    /// To override the contents of this collection use [`set_global_secondary_indexes`](Self::set_global_secondary_indexes).
         135  +
    /// /* BuilderGenerator.kt:412 */To override the contents of this collection use [`set_global_secondary_indexes`](Self::set_global_secondary_indexes).
         136  +
    /* BuilderGenerator.kt:413 */
   85    137   
    ///
   86         -
    /// <p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         138  +
    /// /* BuilderGenerator.kt:414 */<p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         139  +
    /* BuilderGenerator.kt:418 */
   87    140   
    pub fn global_secondary_indexes(mut self, input: crate::types::GlobalSecondaryIndexInfo) -> Self {
         141  +
        /* BuilderGenerator.kt:419 */
   88    142   
        let mut v = self.global_secondary_indexes.unwrap_or_default();
   89    143   
        v.push(input);
   90    144   
        self.global_secondary_indexes = ::std::option::Option::Some(v);
   91    145   
        self
         146  +
        /* BuilderGenerator.kt:418 */
   92    147   
    }
   93         -
    /// <p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         148  +
    /// /* BuilderGenerator.kt:312 */<p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         149  +
    /* BuilderGenerator.kt:314 */
   94    150   
    pub fn set_global_secondary_indexes(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexInfo>>) -> Self {
         151  +
        /* BuilderGenerator.kt:315 */
   95    152   
        self.global_secondary_indexes = input;
   96    153   
        self
         154  +
        /* BuilderGenerator.kt:314 */
   97    155   
    }
   98         -
    /// <p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         156  +
    /// /* BuilderGenerator.kt:334 */<p>Represents the GSI properties for the table when the backup was created. It includes the IndexName, KeySchema, Projection, and ProvisionedThroughput for the GSIs on the table at the time of backup.</p>
         157  +
    /* BuilderGenerator.kt:336 */
   99    158   
    pub fn get_global_secondary_indexes(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::GlobalSecondaryIndexInfo>> {
         159  +
        /* BuilderGenerator.kt:337 */
  100    160   
        &self.global_secondary_indexes
         161  +
        /* BuilderGenerator.kt:336 */
  101    162   
    }
  102         -
    /// <p>Stream settings on the table when the backup was created.</p>
         163  +
    /// /* BuilderGenerator.kt:286 */<p>Stream settings on the table when the backup was created.</p>
         164  +
    /* BuilderGenerator.kt:291 */
  103    165   
    pub fn stream_description(mut self, input: crate::types::StreamSpecification) -> Self {
         166  +
        /* BuilderGenerator.kt:292 */
  104    167   
        self.stream_description = ::std::option::Option::Some(input);
         168  +
        /* BuilderGenerator.kt:293 */
  105    169   
        self
         170  +
        /* BuilderGenerator.kt:291 */
  106    171   
    }
  107         -
    /// <p>Stream settings on the table when the backup was created.</p>
         172  +
    /// /* BuilderGenerator.kt:312 */<p>Stream settings on the table when the backup was created.</p>
         173  +
    /* BuilderGenerator.kt:314 */
  108    174   
    pub fn set_stream_description(mut self, input: ::std::option::Option<crate::types::StreamSpecification>) -> Self {
         175  +
        /* BuilderGenerator.kt:315 */
  109    176   
        self.stream_description = input;
  110    177   
        self
         178  +
        /* BuilderGenerator.kt:314 */
  111    179   
    }
  112         -
    /// <p>Stream settings on the table when the backup was created.</p>
         180  +
    /// /* BuilderGenerator.kt:334 */<p>Stream settings on the table when the backup was created.</p>
         181  +
    /* BuilderGenerator.kt:336 */
  113    182   
    pub fn get_stream_description(&self) -> &::std::option::Option<crate::types::StreamSpecification> {
         183  +
        /* BuilderGenerator.kt:337 */
  114    184   
        &self.stream_description
         185  +
        /* BuilderGenerator.kt:336 */
  115    186   
    }
  116         -
    /// <p>Time to Live settings on the table when the backup was created.</p>
         187  +
    /// /* BuilderGenerator.kt:286 */<p>Time to Live settings on the table when the backup was created.</p>
         188  +
    /* BuilderGenerator.kt:291 */
  117    189   
    pub fn time_to_live_description(mut self, input: crate::types::TimeToLiveDescription) -> Self {
         190  +
        /* BuilderGenerator.kt:292 */
  118    191   
        self.time_to_live_description = ::std::option::Option::Some(input);
         192  +
        /* BuilderGenerator.kt:293 */
  119    193   
        self
         194  +
        /* BuilderGenerator.kt:291 */
  120    195   
    }
  121         -
    /// <p>Time to Live settings on the table when the backup was created.</p>
         196  +
    /// /* BuilderGenerator.kt:312 */<p>Time to Live settings on the table when the backup was created.</p>
         197  +
    /* BuilderGenerator.kt:314 */
  122    198   
    pub fn set_time_to_live_description(mut self, input: ::std::option::Option<crate::types::TimeToLiveDescription>) -> Self {
         199  +
        /* BuilderGenerator.kt:315 */
  123    200   
        self.time_to_live_description = input;
  124    201   
        self
         202  +
        /* BuilderGenerator.kt:314 */
  125    203   
    }
  126         -
    /// <p>Time to Live settings on the table when the backup was created.</p>
         204  +
    /// /* BuilderGenerator.kt:334 */<p>Time to Live settings on the table when the backup was created.</p>
         205  +
    /* BuilderGenerator.kt:336 */
  127    206   
    pub fn get_time_to_live_description(&self) -> &::std::option::Option<crate::types::TimeToLiveDescription> {
         207  +
        /* BuilderGenerator.kt:337 */
  128    208   
        &self.time_to_live_description
         209  +
        /* BuilderGenerator.kt:336 */
  129    210   
    }
  130         -
    /// <p>The description of the server-side encryption status on the table when the backup was created.</p>
         211  +
    /// /* BuilderGenerator.kt:286 */<p>The description of the server-side encryption status on the table when the backup was created.</p>
         212  +
    /* BuilderGenerator.kt:291 */
  131    213   
    pub fn sse_description(mut self, input: crate::types::SseDescription) -> Self {
         214  +
        /* BuilderGenerator.kt:292 */
  132    215   
        self.sse_description = ::std::option::Option::Some(input);
         216  +
        /* BuilderGenerator.kt:293 */
  133    217   
        self
         218  +
        /* BuilderGenerator.kt:291 */
  134    219   
    }
  135         -
    /// <p>The description of the server-side encryption status on the table when the backup was created.</p>
         220  +
    /// /* BuilderGenerator.kt:312 */<p>The description of the server-side encryption status on the table when the backup was created.</p>
         221  +
    /* BuilderGenerator.kt:314 */
  136    222   
    pub fn set_sse_description(mut self, input: ::std::option::Option<crate::types::SseDescription>) -> Self {
         223  +
        /* BuilderGenerator.kt:315 */
  137    224   
        self.sse_description = input;
  138    225   
        self
         226  +
        /* BuilderGenerator.kt:314 */
  139    227   
    }
  140         -
    /// <p>The description of the server-side encryption status on the table when the backup was created.</p>
         228  +
    /// /* BuilderGenerator.kt:334 */<p>The description of the server-side encryption status on the table when the backup was created.</p>
         229  +
    /* BuilderGenerator.kt:336 */
  141    230   
    pub fn get_sse_description(&self) -> &::std::option::Option<crate::types::SseDescription> {
         231  +
        /* BuilderGenerator.kt:337 */
  142    232   
        &self.sse_description
         233  +
        /* BuilderGenerator.kt:336 */
  143    234   
    }
  144         -
    /// Consumes the builder and constructs a [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
         235  +
    /// /* BuilderGenerator.kt:240 */Consumes the builder and constructs a [`SourceTableFeatureDetails`](crate::types::SourceTableFeatureDetails).
         236  +
    /* BuilderGenerator.kt:253 */
  145    237   
    pub fn build(self) -> crate::types::SourceTableFeatureDetails {
         238  +
        /* BuilderGenerator.kt:477 */
  146    239   
        crate::types::SourceTableFeatureDetails {
  147         -
            local_secondary_indexes: self.local_secondary_indexes,
         240  +
            /* BuilderGenerator.kt:481 */ local_secondary_indexes: self.local_secondary_indexes,
         241  +
            /* BuilderGenerator.kt:481 */
  148    242   
            global_secondary_indexes: self.global_secondary_indexes,
         243  +
            /* BuilderGenerator.kt:481 */
  149    244   
            stream_description: self.stream_description,
         245  +
            /* BuilderGenerator.kt:481 */
  150    246   
            time_to_live_description: self.time_to_live_description,
         247  +
            /* BuilderGenerator.kt:481 */
  151    248   
            sse_description: self.sse_description,
         249  +
            /* BuilderGenerator.kt:477 */
  152    250   
        }
         251  +
        /* BuilderGenerator.kt:253 */
  153    252   
    }
         253  +
    /* BuilderGenerator.kt:355 */
  154    254   
}

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/types/_sse_description.rs

@@ -1,1 +166,242 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
    3         -
/// <p>The description of the server-side encryption status on the specified table.</p>
           2  +
/* StructureGenerator.kt:197 */
           3  +
/// /* StructureGenerator.kt:197 */<p>The description of the server-side encryption status on the specified table.</p>
           4  +
/* RustType.kt:516 */
    4      5   
#[non_exhaustive]
           6  +
/* RustType.kt:516 */
    5      7   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
    6         -
pub struct SseDescription {
    7         -
    /// <p>Represents the current state of server-side encryption. The only supported values are:</p>
           8  +
pub /* StructureGenerator.kt:201 */ struct SseDescription {
           9  +
    /// /* StructureGenerator.kt:231 */<p>Represents the current state of server-side encryption. The only supported values are:</p>
    8     10   
    /// <ul>
    9     11   
    /// <li>
   10     12   
    /// <p><code>ENABLED</code> - Server-side encryption is enabled.</p></li>
   11     13   
    /// <li>
   12     14   
    /// <p><code>UPDATING</code> - Server-side encryption is being updated.</p></li>
   13     15   
    /// </ul>
   14     16   
    pub status: ::std::option::Option<crate::types::SseStatus>,
   15         -
    /// <p>Server-side encryption type. The only supported value is:</p>
          17  +
    /// /* StructureGenerator.kt:231 */<p>Server-side encryption type. The only supported value is:</p>
   16     18   
    /// <ul>
   17     19   
    /// <li>
   18     20   
    /// <p><code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The key is stored in your account and is managed by AWS KMS (AWS KMS charges apply).</p></li>
   19     21   
    /// </ul>
   20     22   
    pub sse_type: ::std::option::Option<crate::types::SseType>,
   21         -
    /// <p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
          23  +
    /// /* StructureGenerator.kt:231 */<p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
   22     24   
    pub kms_master_key_arn: ::std::option::Option<::std::string::String>,
   23         -
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
          25  +
    /// /* StructureGenerator.kt:231 */<p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
   24     26   
    pub inaccessible_encryption_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          27  +
    /* StructureGenerator.kt:201 */
   25     28   
}
          29  +
/* StructureGenerator.kt:135 */
   26     30   
impl SseDescription {
   27         -
    /// <p>Represents the current state of server-side encryption. The only supported values are:</p>
          31  +
    /// /* StructureGenerator.kt:231 */<p>Represents the current state of server-side encryption. The only supported values are:</p>
   28     32   
    /// <ul>
   29     33   
    /// <li>
   30     34   
    /// <p><code>ENABLED</code> - Server-side encryption is enabled.</p></li>
   31     35   
    /// <li>
   32     36   
    /// <p><code>UPDATING</code> - Server-side encryption is being updated.</p></li>
   33     37   
    /// </ul>
          38  +
    /* StructureGenerator.kt:166 */
   34     39   
    pub fn status(&self) -> ::std::option::Option<&crate::types::SseStatus> {
          40  +
        /* StructureGenerator.kt:170 */
   35     41   
        self.status.as_ref()
          42  +
        /* StructureGenerator.kt:166 */
   36     43   
    }
   37         -
    /// <p>Server-side encryption type. The only supported value is:</p>
          44  +
    /// /* StructureGenerator.kt:231 */<p>Server-side encryption type. The only supported value is:</p>
   38     45   
    /// <ul>
   39     46   
    /// <li>
   40     47   
    /// <p><code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The key is stored in your account and is managed by AWS KMS (AWS KMS charges apply).</p></li>
   41     48   
    /// </ul>
          49  +
    /* StructureGenerator.kt:166 */
   42     50   
    pub fn sse_type(&self) -> ::std::option::Option<&crate::types::SseType> {
          51  +
        /* StructureGenerator.kt:170 */
   43     52   
        self.sse_type.as_ref()
          53  +
        /* StructureGenerator.kt:166 */
   44     54   
    }
   45         -
    /// <p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
          55  +
    /// /* StructureGenerator.kt:231 */<p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
          56  +
    /* StructureGenerator.kt:166 */
   46     57   
    pub fn kms_master_key_arn(&self) -> ::std::option::Option<&str> {
          58  +
        /* StructureGenerator.kt:169 */
   47     59   
        self.kms_master_key_arn.as_deref()
          60  +
        /* StructureGenerator.kt:166 */
   48     61   
    }
   49         -
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
          62  +
    /// /* StructureGenerator.kt:231 */<p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
          63  +
    /* StructureGenerator.kt:166 */
   50     64   
    pub fn inaccessible_encryption_date_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          65  +
        /* StructureGenerator.kt:170 */
   51     66   
        self.inaccessible_encryption_date_time.as_ref()
          67  +
        /* StructureGenerator.kt:166 */
   52     68   
    }
          69  +
    /* StructureGenerator.kt:135 */
   53     70   
}
          71  +
/* ClientCodegenVisitor.kt:237 */
   54     72   
impl SseDescription {
   55         -
    /// Creates a new builder-style object to manufacture [`SseDescription`](crate::types::SseDescription).
          73  +
    /// /* BuilderGenerator.kt:173 */Creates a new builder-style object to manufacture [`SseDescription`](crate::types::SseDescription).
          74  +
    /* BuilderGenerator.kt:175 */
   56     75   
    pub fn builder() -> crate::types::builders::SseDescriptionBuilder {
          76  +
        /* BuilderGenerator.kt:176 */
   57     77   
        crate::types::builders::SseDescriptionBuilder::default()
          78  +
        /* BuilderGenerator.kt:175 */
   58     79   
    }
          80  +
    /* ClientCodegenVisitor.kt:237 */
   59     81   
}
   60     82   
   61         -
/// A builder for [`SseDescription`](crate::types::SseDescription).
          83  +
/// /* BuilderGenerator.kt:342 */A builder for [`SseDescription`](crate::types::SseDescription).
          84  +
/* RustType.kt:516 */
   62     85   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
          86  +
/* RustType.kt:516 */
   63     87   
#[non_exhaustive]
          88  +
/* BuilderGenerator.kt:345 */
   64     89   
pub struct SseDescriptionBuilder {
   65         -
    pub(crate) status: ::std::option::Option<crate::types::SseStatus>,
   66         -
    pub(crate) sse_type: ::std::option::Option<crate::types::SseType>,
   67         -
    pub(crate) kms_master_key_arn: ::std::option::Option<::std::string::String>,
          90  +
    /* BuilderGenerator.kt:275 */ pub(crate) status: ::std::option::Option<crate::types::SseStatus>,
          91  +
    /* BuilderGenerator.kt:275 */ pub(crate) sse_type: ::std::option::Option<crate::types::SseType>,
          92  +
    /* BuilderGenerator.kt:275 */ pub(crate) kms_master_key_arn: ::std::option::Option<::std::string::String>,
          93  +
    /* BuilderGenerator.kt:275 */
   68     94   
    pub(crate) inaccessible_encryption_date_time: ::std::option::Option<::aws_smithy_types::DateTime>,
          95  +
    /* BuilderGenerator.kt:345 */
   69     96   
}
          97  +
/* BuilderGenerator.kt:355 */
   70     98   
impl SseDescriptionBuilder {
   71         -
    /// <p>Represents the current state of server-side encryption. The only supported values are:</p>
          99  +
    /// /* BuilderGenerator.kt:286 */<p>Represents the current state of server-side encryption. The only supported values are:</p>
   72    100   
    /// <ul>
   73    101   
    /// <li>
   74    102   
    /// <p><code>ENABLED</code> - Server-side encryption is enabled.</p></li>
   75    103   
    /// <li>
   76    104   
    /// <p><code>UPDATING</code> - Server-side encryption is being updated.</p></li>
   77    105   
    /// </ul>
         106  +
    /* BuilderGenerator.kt:291 */
   78    107   
    pub fn status(mut self, input: crate::types::SseStatus) -> Self {
         108  +
        /* BuilderGenerator.kt:292 */
   79    109   
        self.status = ::std::option::Option::Some(input);
         110  +
        /* BuilderGenerator.kt:293 */
   80    111   
        self
         112  +
        /* BuilderGenerator.kt:291 */
   81    113   
    }
   82         -
    /// <p>Represents the current state of server-side encryption. The only supported values are:</p>
         114  +
    /// /* BuilderGenerator.kt:312 */<p>Represents the current state of server-side encryption. The only supported values are:</p>
   83    115   
    /// <ul>
   84    116   
    /// <li>
   85    117   
    /// <p><code>ENABLED</code> - Server-side encryption is enabled.</p></li>
   86    118   
    /// <li>
   87    119   
    /// <p><code>UPDATING</code> - Server-side encryption is being updated.</p></li>
   88    120   
    /// </ul>
         121  +
    /* BuilderGenerator.kt:314 */
   89    122   
    pub fn set_status(mut self, input: ::std::option::Option<crate::types::SseStatus>) -> Self {
         123  +
        /* BuilderGenerator.kt:315 */
   90    124   
        self.status = input;
   91    125   
        self
         126  +
        /* BuilderGenerator.kt:314 */
   92    127   
    }
   93         -
    /// <p>Represents the current state of server-side encryption. The only supported values are:</p>
         128  +
    /// /* BuilderGenerator.kt:334 */<p>Represents the current state of server-side encryption. The only supported values are:</p>
   94    129   
    /// <ul>
   95    130   
    /// <li>
   96    131   
    /// <p><code>ENABLED</code> - Server-side encryption is enabled.</p></li>
   97    132   
    /// <li>
   98    133   
    /// <p><code>UPDATING</code> - Server-side encryption is being updated.</p></li>
   99    134   
    /// </ul>
         135  +
    /* BuilderGenerator.kt:336 */
  100    136   
    pub fn get_status(&self) -> &::std::option::Option<crate::types::SseStatus> {
         137  +
        /* BuilderGenerator.kt:337 */
  101    138   
        &self.status
         139  +
        /* BuilderGenerator.kt:336 */
  102    140   
    }
  103         -
    /// <p>Server-side encryption type. The only supported value is:</p>
         141  +
    /// /* BuilderGenerator.kt:286 */<p>Server-side encryption type. The only supported value is:</p>
  104    142   
    /// <ul>
  105    143   
    /// <li>
  106    144   
    /// <p><code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The key is stored in your account and is managed by AWS KMS (AWS KMS charges apply).</p></li>
  107    145   
    /// </ul>
         146  +
    /* BuilderGenerator.kt:291 */
  108    147   
    pub fn sse_type(mut self, input: crate::types::SseType) -> Self {
         148  +
        /* BuilderGenerator.kt:292 */
  109    149   
        self.sse_type = ::std::option::Option::Some(input);
         150  +
        /* BuilderGenerator.kt:293 */
  110    151   
        self
         152  +
        /* BuilderGenerator.kt:291 */
  111    153   
    }
  112         -
    /// <p>Server-side encryption type. The only supported value is:</p>
         154  +
    /// /* BuilderGenerator.kt:312 */<p>Server-side encryption type. The only supported value is:</p>
  113    155   
    /// <ul>
  114    156   
    /// <li>
  115    157   
    /// <p><code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The key is stored in your account and is managed by AWS KMS (AWS KMS charges apply).</p></li>
  116    158   
    /// </ul>
         159  +
    /* BuilderGenerator.kt:314 */
  117    160   
    pub fn set_sse_type(mut self, input: ::std::option::Option<crate::types::SseType>) -> Self {
         161  +
        /* BuilderGenerator.kt:315 */
  118    162   
        self.sse_type = input;
  119    163   
        self
         164  +
        /* BuilderGenerator.kt:314 */
  120    165   
    }
  121         -
    /// <p>Server-side encryption type. The only supported value is:</p>
         166  +
    /// /* BuilderGenerator.kt:334 */<p>Server-side encryption type. The only supported value is:</p>
  122    167   
    /// <ul>
  123    168   
    /// <li>
  124    169   
    /// <p><code>KMS</code> - Server-side encryption that uses AWS Key Management Service. The key is stored in your account and is managed by AWS KMS (AWS KMS charges apply).</p></li>
  125    170   
    /// </ul>
         171  +
    /* BuilderGenerator.kt:336 */
  126    172   
    pub fn get_sse_type(&self) -> &::std::option::Option<crate::types::SseType> {
         173  +
        /* BuilderGenerator.kt:337 */
  127    174   
        &self.sse_type
         175  +
        /* BuilderGenerator.kt:336 */
  128    176   
    }
  129         -
    /// <p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         177  +
    /// /* BuilderGenerator.kt:286 */<p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         178  +
    /* BuilderGenerator.kt:291 */
  130    179   
    pub fn kms_master_key_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         180  +
        /* BuilderGenerator.kt:292 */
  131    181   
        self.kms_master_key_arn = ::std::option::Option::Some(input.into());
         182  +
        /* BuilderGenerator.kt:293 */
  132    183   
        self
         184  +
        /* BuilderGenerator.kt:291 */
  133    185   
    }
  134         -
    /// <p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         186  +
    /// /* BuilderGenerator.kt:312 */<p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         187  +
    /* BuilderGenerator.kt:314 */
  135    188   
    pub fn set_kms_master_key_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         189  +
        /* BuilderGenerator.kt:315 */
  136    190   
        self.kms_master_key_arn = input;
  137    191   
        self
         192  +
        /* BuilderGenerator.kt:314 */
  138    193   
    }
  139         -
    /// <p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         194  +
    /// /* BuilderGenerator.kt:334 */<p>The AWS KMS customer master key (CMK) ARN used for the AWS KMS encryption.</p>
         195  +
    /* BuilderGenerator.kt:336 */
  140    196   
    pub fn get_kms_master_key_arn(&self) -> &::std::option::Option<::std::string::String> {
         197  +
        /* BuilderGenerator.kt:337 */
  141    198   
        &self.kms_master_key_arn
         199  +
        /* BuilderGenerator.kt:336 */
  142    200   
    }
  143         -
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         201  +
    /// /* BuilderGenerator.kt:286 */<p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         202  +
    /* BuilderGenerator.kt:291 */
  144    203   
    pub fn inaccessible_encryption_date_time(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         204  +
        /* BuilderGenerator.kt:292 */
  145    205   
        self.inaccessible_encryption_date_time = ::std::option::Option::Some(input);
         206  +
        /* BuilderGenerator.kt:293 */
  146    207   
        self
         208  +
        /* BuilderGenerator.kt:291 */
  147    209   
    }
  148         -
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         210  +
    /// /* BuilderGenerator.kt:312 */<p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         211  +
    /* BuilderGenerator.kt:314 */
  149    212   
    pub fn set_inaccessible_encryption_date_time(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         213  +
        /* BuilderGenerator.kt:315 */
  150    214   
        self.inaccessible_encryption_date_time = input;
  151    215   
        self
         216  +
        /* BuilderGenerator.kt:314 */
  152    217   
    }
  153         -
    /// <p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         218  +
    /// /* BuilderGenerator.kt:334 */<p>Indicates the time, in UNIX epoch date format, when DynamoDB detected that the table's AWS KMS key was inaccessible. This attribute will automatically be cleared when DynamoDB detects that the table's AWS KMS key is accessible again. DynamoDB will initiate the table archival process when table's AWS KMS key remains inaccessible for more than seven days from this date.</p>
         219  +
    /* BuilderGenerator.kt:336 */
  154    220   
    pub fn get_inaccessible_encryption_date_time(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         221  +
        /* BuilderGenerator.kt:337 */
  155    222   
        &self.inaccessible_encryption_date_time
         223  +
        /* BuilderGenerator.kt:336 */
  156    224   
    }
  157         -
    /// Consumes the builder and constructs a [`SseDescription`](crate::types::SseDescription).
         225  +
    /// /* BuilderGenerator.kt:240 */Consumes the builder and constructs a [`SseDescription`](crate::types::SseDescription).
         226  +
    /* BuilderGenerator.kt:253 */
  158    227   
    pub fn build(self) -> crate::types::SseDescription {
         228  +
        /* BuilderGenerator.kt:477 */
  159    229   
        crate::types::SseDescription {
  160         -
            status: self.status,
         230  +
            /* BuilderGenerator.kt:481 */ status: self.status,
         231  +
            /* BuilderGenerator.kt:481 */
  161    232   
            sse_type: self.sse_type,
         233  +
            /* BuilderGenerator.kt:481 */
  162    234   
            kms_master_key_arn: self.kms_master_key_arn,
         235  +
            /* BuilderGenerator.kt:481 */
  163    236   
            inaccessible_encryption_date_time: self.inaccessible_encryption_date_time,
         237  +
            /* BuilderGenerator.kt:477 */
  164    238   
        }
         239  +
        /* BuilderGenerator.kt:253 */
  165    240   
    }
         241  +
    /* BuilderGenerator.kt:355 */
  166    242   
}