AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_input_serialization.rs

@@ -21,21 +104,115 @@
   41     41   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   42     42   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   43     43   
        if let Some(ref val) = self.csv {
   44     44   
            ser.write_struct(&INPUTSERIALIZATION_MEMBER_CSV, val)?;
   45     45   
        }
   46     46   
        Ok(())
   47     47   
    }
   48     48   
}
   49     49   
impl InputSerialization {
   50     50   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   51         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   52         -
        deserializer: &mut D,
          51  +
    pub fn deserialize(
          52  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   53     53   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   54     54   
        #[allow(unused_variables, unused_mut)]
   55     55   
        let mut builder = Self::builder();
   56     56   
        #[allow(
   57     57   
            unused_variables,
   58     58   
            unreachable_code,
   59     59   
            clippy::single_match,
   60     60   
            clippy::match_single_binding,
   61     61   
            clippy::diverging_sub_expression
   62     62   
        )]
   63         -
        deserializer.read_struct(&INPUTSERIALIZATION_SCHEMA, (), |_, member, deser| {
          63  +
        deserializer.read_struct(&INPUTSERIALIZATION_SCHEMA, &mut |member, deser| {
   64     64   
            match member.member_index() {
   65     65   
                Some(0) => {
   66     66   
                    builder.csv = Some(crate::types::CsvInput::deserialize(deser)?);
   67     67   
                }
   68     68   
                _ => {}
   69     69   
            }
   70     70   
            Ok(())
   71     71   
        })?;
   72     72   
        Ok(builder.build())
   73     73   
    }
   74     74   
}
          75  +
impl InputSerialization {
          76  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          77  +
    pub fn deserialize_with_response(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          80  +
        _status: u16,
          81  +
        _body: &[u8],
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        Self::deserialize(deserializer)
          84  +
    }
          85  +
}
   75     86   
impl InputSerialization {
   76     87   
    /// Creates a new builder-style object to manufacture [`InputSerialization`](crate::types::InputSerialization).
   77     88   
    pub fn builder() -> crate::types::builders::InputSerializationBuilder {
   78     89   
        crate::types::builders::InputSerializationBuilder::default()
   79     90   
    }
   80     91   
}
   81     92   
   82     93   
/// A builder for [`InputSerialization`](crate::types::InputSerialization).
   83     94   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   84     95   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_inventory_retrieval_job_description.rs

@@ -22,22 +201,212 @@
   42     42   
    "com.amazonaws.glacier",
   43     43   
    "InventoryRetrievalJobDescription",
   44     44   
);
   45     45   
static INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.glacier#InventoryRetrievalJobDescription$Format",
   48     48   
        "com.amazonaws.glacier",
   49     49   
        "InventoryRetrievalJobDescription",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "format",
          52  +
    "Format",
   53     53   
    0,
   54     54   
);
   55     55   
static INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.glacier#InventoryRetrievalJobDescription$StartDate",
   58     58   
        "com.amazonaws.glacier",
   59     59   
        "InventoryRetrievalJobDescription",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "start_date",
          62  +
    "StartDate",
   63     63   
    1,
   64     64   
);
   65     65   
static INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static(
   67     67   
        "com.amazonaws.glacier#InventoryRetrievalJobDescription$EndDate",
   68     68   
        "com.amazonaws.glacier",
   69     69   
        "InventoryRetrievalJobDescription",
   70     70   
    ),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "end_date",
          72  +
    "EndDate",
   73     73   
    2,
   74     74   
);
   75     75   
static INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.glacier#InventoryRetrievalJobDescription$Limit",
   78     78   
        "com.amazonaws.glacier",
   79     79   
        "InventoryRetrievalJobDescription",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::String,
   82         -
    "limit",
          82  +
    "Limit",
   83     83   
    3,
   84     84   
);
   85     85   
static INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.glacier#InventoryRetrievalJobDescription$Marker",
   88     88   
        "com.amazonaws.glacier",
   89     89   
        "InventoryRetrievalJobDescription",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "marker",
          92  +
    "Marker",
   93     93   
    4,
   94     94   
);
   95     95   
static INVENTORYRETRIEVALJOBDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   96     96   
    INVENTORYRETRIEVALJOBDESCRIPTION_SCHEMA_ID,
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98     98   
    &[
   99     99   
        &INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_FORMAT,
  100    100   
        &INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_START_DATE,
  101    101   
        &INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_END_DATE,
  102    102   
        &INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_LIMIT,
  103    103   
        &INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_MARKER,
  104    104   
    ],
  105    105   
);
  106    106   
impl InventoryRetrievalJobDescription {
  107    107   
    /// The schema for this shape.
  108    108   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYRETRIEVALJOBDESCRIPTION_SCHEMA;
  109    109   
}
  110    110   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryRetrievalJobDescription {
  111    111   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  112    112   
    fn serialize_members(
  113    113   
        &self,
  114    114   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  115    115   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        if let Some(ref val) = self.format {
  117    117   
            ser.write_string(&INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_FORMAT, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.start_date {
  120    120   
            ser.write_string(&INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_START_DATE, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.end_date {
  123    123   
            ser.write_string(&INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_END_DATE, val)?;
  124    124   
        }
  125    125   
        if let Some(ref val) = self.limit {
  126    126   
            ser.write_string(&INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_LIMIT, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.marker {
  129    129   
            ser.write_string(&INVENTORYRETRIEVALJOBDESCRIPTION_MEMBER_MARKER, val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl InventoryRetrievalJobDescription {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&INVENTORYRETRIEVALJOBDESCRIPTION_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&INVENTORYRETRIEVALJOBDESCRIPTION_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.format = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.start_date = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                Some(2) => {
  157    157   
                    builder.end_date = Some(deser.read_string(member)?);
  158    158   
                }
  159    159   
                Some(3) => {
  160    160   
                    builder.limit = Some(deser.read_string(member)?);
  161    161   
                }
  162    162   
                Some(4) => {
  163    163   
                    builder.marker = Some(deser.read_string(member)?);
  164    164   
                }
  165    165   
                _ => {}
  166    166   
            }
  167    167   
            Ok(())
  168    168   
        })?;
  169    169   
        Ok(builder.build())
  170    170   
    }
  171    171   
}
         172  +
impl InventoryRetrievalJobDescription {
         173  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         174  +
    pub fn deserialize_with_response(
         175  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         176  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         177  +
        _status: u16,
         178  +
        _body: &[u8],
         179  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         180  +
        Self::deserialize(deserializer)
         181  +
    }
         182  +
}
  172    183   
impl InventoryRetrievalJobDescription {
  173    184   
    /// Creates a new builder-style object to manufacture [`InventoryRetrievalJobDescription`](crate::types::InventoryRetrievalJobDescription).
  174    185   
    pub fn builder() -> crate::types::builders::InventoryRetrievalJobDescriptionBuilder {
  175    186   
        crate::types::builders::InventoryRetrievalJobDescriptionBuilder::default()
  176    187   
    }
  177    188   
}
  178    189   
  179    190   
/// A builder for [`InventoryRetrievalJobDescription`](crate::types::InventoryRetrievalJobDescription).
  180    191   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  181    192   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_inventory_retrieval_job_input.rs

@@ -16,16 +178,189 @@
   36     36   
    "com.amazonaws.glacier",
   37     37   
    "InventoryRetrievalJobInput",
   38     38   
);
   39     39   
static INVENTORYRETRIEVALJOBINPUT_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.glacier#InventoryRetrievalJobInput$StartDate",
   42     42   
        "com.amazonaws.glacier",
   43     43   
        "InventoryRetrievalJobInput",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "start_date",
          46  +
    "StartDate",
   47     47   
    0,
   48     48   
);
   49     49   
static INVENTORYRETRIEVALJOBINPUT_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.glacier#InventoryRetrievalJobInput$EndDate",
   52     52   
        "com.amazonaws.glacier",
   53     53   
        "InventoryRetrievalJobInput",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "end_date",
          56  +
    "EndDate",
   57     57   
    1,
   58     58   
);
   59     59   
static INVENTORYRETRIEVALJOBINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.glacier#InventoryRetrievalJobInput$Limit",
   62     62   
        "com.amazonaws.glacier",
   63     63   
        "InventoryRetrievalJobInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "limit",
          66  +
    "Limit",
   67     67   
    2,
   68     68   
);
   69     69   
static INVENTORYRETRIEVALJOBINPUT_MEMBER_MARKER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.glacier#InventoryRetrievalJobInput$Marker",
   72     72   
        "com.amazonaws.glacier",
   73     73   
        "InventoryRetrievalJobInput",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "marker",
          76  +
    "Marker",
   77     77   
    3,
   78     78   
);
   79     79   
static INVENTORYRETRIEVALJOBINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    INVENTORYRETRIEVALJOBINPUT_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &INVENTORYRETRIEVALJOBINPUT_MEMBER_START_DATE,
   84     84   
        &INVENTORYRETRIEVALJOBINPUT_MEMBER_END_DATE,
   85     85   
        &INVENTORYRETRIEVALJOBINPUT_MEMBER_LIMIT,
   86     86   
        &INVENTORYRETRIEVALJOBINPUT_MEMBER_MARKER,
   87     87   
    ],
   88     88   
);
   89     89   
impl InventoryRetrievalJobInput {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVENTORYRETRIEVALJOBINPUT_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for InventoryRetrievalJobInput {
   94     94   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   95     95   
    fn serialize_members(
   96     96   
        &self,
   97     97   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   98     98   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        if let Some(ref val) = self.start_date {
  100    100   
            ser.write_string(&INVENTORYRETRIEVALJOBINPUT_MEMBER_START_DATE, val)?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.end_date {
  103    103   
            ser.write_string(&INVENTORYRETRIEVALJOBINPUT_MEMBER_END_DATE, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.limit {
  106    106   
            ser.write_string(&INVENTORYRETRIEVALJOBINPUT_MEMBER_LIMIT, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.marker {
  109    109   
            ser.write_string(&INVENTORYRETRIEVALJOBINPUT_MEMBER_MARKER, val)?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl InventoryRetrievalJobInput {
  115    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  116         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  117         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  118    118   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  119    119   
        #[allow(unused_variables, unused_mut)]
  120    120   
        let mut builder = Self::builder();
  121    121   
        #[allow(
  122    122   
            unused_variables,
  123    123   
            unreachable_code,
  124    124   
            clippy::single_match,
  125    125   
            clippy::match_single_binding,
  126    126   
            clippy::diverging_sub_expression
  127    127   
        )]
  128         -
        deserializer.read_struct(&INVENTORYRETRIEVALJOBINPUT_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&INVENTORYRETRIEVALJOBINPUT_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.start_date = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.end_date = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.limit = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.marker = Some(deser.read_string(member)?);
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl InventoryRetrievalJobInput {
         150  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         151  +
    pub fn deserialize_with_response(
         152  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         153  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         154  +
        _status: u16,
         155  +
        _body: &[u8],
         156  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         157  +
        Self::deserialize(deserializer)
         158  +
    }
         159  +
}
  149    160   
impl InventoryRetrievalJobInput {
  150    161   
    /// Creates a new builder-style object to manufacture [`InventoryRetrievalJobInput`](crate::types::InventoryRetrievalJobInput).
  151    162   
    pub fn builder() -> crate::types::builders::InventoryRetrievalJobInputBuilder {
  152    163   
        crate::types::builders::InventoryRetrievalJobInputBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`InventoryRetrievalJobInput`](crate::types::InventoryRetrievalJobInput).
  157    168   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  158    169   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_job_parameters.rs

@@ -47,47 +181,181 @@
   67     67   
    /// <p>Contains information about the location where the select job results are stored.</p>
   68     68   
    pub fn output_location(&self) -> ::std::option::Option<&crate::types::OutputLocation> {
   69     69   
        self.output_location.as_ref()
   70     70   
    }
   71     71   
}
   72     72   
static JOBPARAMETERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters", "com.amazonaws.glacier", "JobParameters");
   74     74   
static JOBPARAMETERS_MEMBER_FORMAT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters$Format", "com.amazonaws.glacier", "JobParameters"),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "format",
          77  +
    "Format",
   78     78   
    0,
   79     79   
);
   80     80   
static JOBPARAMETERS_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters$Type", "com.amazonaws.glacier", "JobParameters"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "r##type",
          83  +
    "Type",
   84     84   
    1,
   85     85   
);
   86     86   
static JOBPARAMETERS_MEMBER_ARCHIVE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters$ArchiveId", "com.amazonaws.glacier", "JobParameters"),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "archive_id",
          89  +
    "ArchiveId",
   90     90   
    2,
   91     91   
);
   92     92   
static JOBPARAMETERS_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.glacier#JobParameters$Description",
   95     95   
        "com.amazonaws.glacier",
   96     96   
        "JobParameters",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "description",
          99  +
    "Description",
  100    100   
    3,
  101    101   
);
  102    102   
static JOBPARAMETERS_MEMBER_SNS_TOPIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters$SNSTopic", "com.amazonaws.glacier", "JobParameters"),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "sns_topic",
         105  +
    "SNSTopic",
  106    106   
    4,
  107    107   
);
  108    108   
static JOBPARAMETERS_MEMBER_RETRIEVAL_BYTE_RANGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.glacier#JobParameters$RetrievalByteRange",
  111    111   
        "com.amazonaws.glacier",
  112    112   
        "JobParameters",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "retrieval_byte_range",
         115  +
    "RetrievalByteRange",
  116    116   
    5,
  117    117   
);
  118    118   
static JOBPARAMETERS_MEMBER_TIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#JobParameters$Tier", "com.amazonaws.glacier", "JobParameters"),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "tier",
         121  +
    "Tier",
  122    122   
    6,
  123    123   
);
  124    124   
static JOBPARAMETERS_MEMBER_INVENTORY_RETRIEVAL_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.glacier#JobParameters$InventoryRetrievalParameters",
  127    127   
        "com.amazonaws.glacier",
  128    128   
        "JobParameters",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::Structure,
  131         -
    "inventory_retrieval_parameters",
         131  +
    "InventoryRetrievalParameters",
  132    132   
    7,
  133    133   
);
  134    134   
static JOBPARAMETERS_MEMBER_SELECT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.glacier#JobParameters$SelectParameters",
  137    137   
        "com.amazonaws.glacier",
  138    138   
        "JobParameters",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::Structure,
  141         -
    "select_parameters",
         141  +
    "SelectParameters",
  142    142   
    8,
  143    143   
);
  144    144   
static JOBPARAMETERS_MEMBER_OUTPUT_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.glacier#JobParameters$OutputLocation",
  147    147   
        "com.amazonaws.glacier",
  148    148   
        "JobParameters",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::Structure,
  151         -
    "output_location",
         151  +
    "OutputLocation",
  152    152   
    9,
  153    153   
);
  154    154   
static JOBPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  155    155   
    JOBPARAMETERS_SCHEMA_ID,
  156    156   
    ::aws_smithy_schema::ShapeType::Structure,
  157    157   
    &[
  158    158   
        &JOBPARAMETERS_MEMBER_FORMAT,
  159    159   
        &JOBPARAMETERS_MEMBER_TYPE,
  160    160   
        &JOBPARAMETERS_MEMBER_ARCHIVE_ID,
  161    161   
        &JOBPARAMETERS_MEMBER_DESCRIPTION,
@@ -185,185 +295,306 @@
  205    205   
            ser.write_struct(&JOBPARAMETERS_MEMBER_SELECT_PARAMETERS, val)?;
  206    206   
        }
  207    207   
        if let Some(ref val) = self.output_location {
  208    208   
            ser.write_struct(&JOBPARAMETERS_MEMBER_OUTPUT_LOCATION, val)?;
  209    209   
        }
  210    210   
        Ok(())
  211    211   
    }
  212    212   
}
  213    213   
impl JobParameters {
  214    214   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  215         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  216         -
        deserializer: &mut D,
         215  +
    pub fn deserialize(
         216  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  217    217   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  218    218   
        #[allow(unused_variables, unused_mut)]
  219    219   
        let mut builder = Self::builder();
  220    220   
        #[allow(
  221    221   
            unused_variables,
  222    222   
            unreachable_code,
  223    223   
            clippy::single_match,
  224    224   
            clippy::match_single_binding,
  225    225   
            clippy::diverging_sub_expression
  226    226   
        )]
  227         -
        deserializer.read_struct(&JOBPARAMETERS_SCHEMA, (), |_, member, deser| {
         227  +
        deserializer.read_struct(&JOBPARAMETERS_SCHEMA, &mut |member, deser| {
  228    228   
            match member.member_index() {
  229    229   
                Some(0) => {
  230    230   
                    builder.format = Some(deser.read_string(member)?);
  231    231   
                }
  232    232   
                Some(1) => {
  233    233   
                    builder.r#type = Some(deser.read_string(member)?);
  234    234   
                }
  235    235   
                Some(2) => {
  236    236   
                    builder.archive_id = Some(deser.read_string(member)?);
  237    237   
                }
  238    238   
                Some(3) => {
  239    239   
                    builder.description = Some(deser.read_string(member)?);
  240    240   
                }
  241    241   
                Some(4) => {
  242    242   
                    builder.sns_topic = Some(deser.read_string(member)?);
  243    243   
                }
  244    244   
                Some(5) => {
  245    245   
                    builder.retrieval_byte_range = Some(deser.read_string(member)?);
  246    246   
                }
  247    247   
                Some(6) => {
  248    248   
                    builder.tier = Some(deser.read_string(member)?);
  249    249   
                }
  250    250   
                Some(7) => {
  251    251   
                    builder.inventory_retrieval_parameters = Some(crate::types::InventoryRetrievalJobInput::deserialize(deser)?);
  252    252   
                }
  253    253   
                Some(8) => {
  254    254   
                    builder.select_parameters = Some(crate::types::SelectParameters::deserialize(deser)?);
  255    255   
                }
  256    256   
                Some(9) => {
  257    257   
                    builder.output_location = Some(crate::types::OutputLocation::deserialize(deser)?);
  258    258   
                }
  259    259   
                _ => {}
  260    260   
            }
  261    261   
            Ok(())
  262    262   
        })?;
  263    263   
        Ok(builder.build())
  264    264   
    }
  265    265   
}
         266  +
impl JobParameters {
         267  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         268  +
    pub fn deserialize_with_response(
         269  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         270  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         271  +
        _status: u16,
         272  +
        _body: &[u8],
         273  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         274  +
        Self::deserialize(deserializer)
         275  +
    }
         276  +
}
  266    277   
impl JobParameters {
  267    278   
    /// Creates a new builder-style object to manufacture [`JobParameters`](crate::types::JobParameters).
  268    279   
    pub fn builder() -> crate::types::builders::JobParametersBuilder {
  269    280   
        crate::types::builders::JobParametersBuilder::default()
  270    281   
    }
  271    282   
}
  272    283   
  273    284   
/// A builder for [`JobParameters`](crate::types::JobParameters).
  274    285   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  275    286   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_output_location.rs

@@ -1,1 +100,111 @@
   11     11   
    /// <p>Describes an S3 location that will receive the results of the job request.</p>
   12     12   
    pub fn s3(&self) -> ::std::option::Option<&crate::types::S3Location> {
   13     13   
        self.s3.as_ref()
   14     14   
    }
   15     15   
}
   16     16   
static OUTPUTLOCATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#OutputLocation", "com.amazonaws.glacier", "OutputLocation");
   18     18   
static OUTPUTLOCATION_MEMBER_S3: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#OutputLocation$S3", "com.amazonaws.glacier", "OutputLocation"),
   20     20   
    ::aws_smithy_schema::ShapeType::Structure,
   21         -
    "s3",
          21  +
    "S3",
   22     22   
    0,
   23     23   
);
   24     24   
static OUTPUTLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    OUTPUTLOCATION_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&OUTPUTLOCATION_MEMBER_S3],
   28     28   
);
   29     29   
impl OutputLocation {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &OUTPUTLOCATION_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for OutputLocation {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        if let Some(ref val) = self.s3 {
   40     40   
            ser.write_struct(&OUTPUTLOCATION_MEMBER_S3, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl OutputLocation {
   46     46   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   47         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   48         -
        deserializer: &mut D,
          47  +
    pub fn deserialize(
          48  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   49     49   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   50     50   
        #[allow(unused_variables, unused_mut)]
   51     51   
        let mut builder = Self::builder();
   52     52   
        #[allow(
   53     53   
            unused_variables,
   54     54   
            unreachable_code,
   55     55   
            clippy::single_match,
   56     56   
            clippy::match_single_binding,
   57     57   
            clippy::diverging_sub_expression
   58     58   
        )]
   59         -
        deserializer.read_struct(&OUTPUTLOCATION_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&OUTPUTLOCATION_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.s3 = Some(crate::types::S3Location::deserialize(deser)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl OutputLocation {
          72  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          73  +
    pub fn deserialize_with_response(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          75  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          76  +
        _status: u16,
          77  +
        _body: &[u8],
          78  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          79  +
        Self::deserialize(deserializer)
          80  +
    }
          81  +
}
   71     82   
impl OutputLocation {
   72     83   
    /// Creates a new builder-style object to manufacture [`OutputLocation`](crate::types::OutputLocation).
   73     84   
    pub fn builder() -> crate::types::builders::OutputLocationBuilder {
   74     85   
        crate::types::builders::OutputLocationBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`OutputLocation`](crate::types::OutputLocation).
   79     90   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   80     91   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_output_serialization.rs

@@ -24,24 +107,118 @@
   44     44   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   45     45   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   46     46   
        if let Some(ref val) = self.csv {
   47     47   
            ser.write_struct(&OUTPUTSERIALIZATION_MEMBER_CSV, val)?;
   48     48   
        }
   49     49   
        Ok(())
   50     50   
    }
   51     51   
}
   52     52   
impl OutputSerialization {
   53     53   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   54         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   55         -
        deserializer: &mut D,
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   56     56   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   57     57   
        #[allow(unused_variables, unused_mut)]
   58     58   
        let mut builder = Self::builder();
   59     59   
        #[allow(
   60     60   
            unused_variables,
   61     61   
            unreachable_code,
   62     62   
            clippy::single_match,
   63     63   
            clippy::match_single_binding,
   64     64   
            clippy::diverging_sub_expression
   65     65   
        )]
   66         -
        deserializer.read_struct(&OUTPUTSERIALIZATION_SCHEMA, (), |_, member, deser| {
          66  +
        deserializer.read_struct(&OUTPUTSERIALIZATION_SCHEMA, &mut |member, deser| {
   67     67   
            match member.member_index() {
   68     68   
                Some(0) => {
   69     69   
                    builder.csv = Some(crate::types::CsvOutput::deserialize(deser)?);
   70     70   
                }
   71     71   
                _ => {}
   72     72   
            }
   73     73   
            Ok(())
   74     74   
        })?;
   75     75   
        Ok(builder.build())
   76     76   
    }
   77     77   
}
          78  +
impl OutputSerialization {
          79  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          80  +
    pub fn deserialize_with_response(
          81  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          82  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          83  +
        _status: u16,
          84  +
        _body: &[u8],
          85  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          86  +
        Self::deserialize(deserializer)
          87  +
    }
          88  +
}
   78     89   
impl OutputSerialization {
   79     90   
    /// Creates a new builder-style object to manufacture [`OutputSerialization`](crate::types::OutputSerialization).
   80     91   
    pub fn builder() -> crate::types::builders::OutputSerializationBuilder {
   81     92   
        crate::types::builders::OutputSerializationBuilder::default()
   82     93   
    }
   83     94   
}
   84     95   
   85     96   
/// A builder for [`OutputSerialization`](crate::types::OutputSerialization).
   86     97   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   87     98   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_part_list_element.rs

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static PARTLISTELEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#PartListElement", "com.amazonaws.glacier", "PartListElement");
   24     24   
static PARTLISTELEMENT_MEMBER_RANGE_IN_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.glacier#PartListElement$RangeInBytes",
   27     27   
        "com.amazonaws.glacier",
   28     28   
        "PartListElement",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "range_in_bytes",
          31  +
    "RangeInBytes",
   32     32   
    0,
   33     33   
);
   34     34   
static PARTLISTELEMENT_MEMBER_SHA256_TREE_HASH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.glacier#PartListElement$SHA256TreeHash",
   37     37   
        "com.amazonaws.glacier",
   38     38   
        "PartListElement",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "sha256_tree_hash",
          41  +
    "SHA256TreeHash",
   42     42   
    1,
   43     43   
);
   44     44   
static PARTLISTELEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    PARTLISTELEMENT_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&PARTLISTELEMENT_MEMBER_RANGE_IN_BYTES, &PARTLISTELEMENT_MEMBER_SHA256_TREE_HASH],
   48     48   
);
   49     49   
impl PartListElement {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PARTLISTELEMENT_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for PartListElement {
   54     54   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   55     55   
    fn serialize_members(
   56     56   
        &self,
   57     57   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   58     58   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   59     59   
        if let Some(ref val) = self.range_in_bytes {
   60     60   
            ser.write_string(&PARTLISTELEMENT_MEMBER_RANGE_IN_BYTES, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.sha256_tree_hash {
   63     63   
            ser.write_string(&PARTLISTELEMENT_MEMBER_SHA256_TREE_HASH, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl PartListElement {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&PARTLISTELEMENT_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&PARTLISTELEMENT_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.range_in_bytes = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.sha256_tree_hash = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl PartListElement {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   97    108   
impl PartListElement {
   98    109   
    /// Creates a new builder-style object to manufacture [`PartListElement`](crate::types::PartListElement).
   99    110   
    pub fn builder() -> crate::types::builders::PartListElementBuilder {
  100    111   
        crate::types::builders::PartListElementBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`PartListElement`](crate::types::PartListElement).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_provisioned_capacity_description.rs

@@ -10,10 +155,166 @@
   30     30   
    "com.amazonaws.glacier",
   31     31   
    "ProvisionedCapacityDescription",
   32     32   
);
   33     33   
static PROVISIONEDCAPACITYDESCRIPTION_MEMBER_CAPACITY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.glacier#ProvisionedCapacityDescription$CapacityId",
   36     36   
        "com.amazonaws.glacier",
   37     37   
        "ProvisionedCapacityDescription",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "capacity_id",
          40  +
    "CapacityId",
   41     41   
    0,
   42     42   
);
   43     43   
static PROVISIONEDCAPACITYDESCRIPTION_MEMBER_START_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.glacier#ProvisionedCapacityDescription$StartDate",
   46     46   
        "com.amazonaws.glacier",
   47     47   
        "ProvisionedCapacityDescription",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "start_date",
          50  +
    "StartDate",
   51     51   
    1,
   52     52   
);
   53     53   
static PROVISIONEDCAPACITYDESCRIPTION_MEMBER_EXPIRATION_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.glacier#ProvisionedCapacityDescription$ExpirationDate",
   56     56   
        "com.amazonaws.glacier",
   57     57   
        "ProvisionedCapacityDescription",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "expiration_date",
          60  +
    "ExpirationDate",
   61     61   
    2,
   62     62   
);
   63     63   
static PROVISIONEDCAPACITYDESCRIPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   64     64   
    PROVISIONEDCAPACITYDESCRIPTION_SCHEMA_ID,
   65     65   
    ::aws_smithy_schema::ShapeType::Structure,
   66     66   
    &[
   67     67   
        &PROVISIONEDCAPACITYDESCRIPTION_MEMBER_CAPACITY_ID,
   68     68   
        &PROVISIONEDCAPACITYDESCRIPTION_MEMBER_START_DATE,
   69     69   
        &PROVISIONEDCAPACITYDESCRIPTION_MEMBER_EXPIRATION_DATE,
   70     70   
    ],
   71     71   
);
   72     72   
impl ProvisionedCapacityDescription {
   73     73   
    /// The schema for this shape.
   74     74   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PROVISIONEDCAPACITYDESCRIPTION_SCHEMA;
   75     75   
}
   76     76   
impl ::aws_smithy_schema::serde::SerializableStruct for ProvisionedCapacityDescription {
   77     77   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   78     78   
    fn serialize_members(
   79     79   
        &self,
   80     80   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   81     81   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   82     82   
        if let Some(ref val) = self.capacity_id {
   83     83   
            ser.write_string(&PROVISIONEDCAPACITYDESCRIPTION_MEMBER_CAPACITY_ID, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.start_date {
   86     86   
            ser.write_string(&PROVISIONEDCAPACITYDESCRIPTION_MEMBER_START_DATE, val)?;
   87     87   
        }
   88     88   
        if let Some(ref val) = self.expiration_date {
   89     89   
            ser.write_string(&PROVISIONEDCAPACITYDESCRIPTION_MEMBER_EXPIRATION_DATE, val)?;
   90     90   
        }
   91     91   
        Ok(())
   92     92   
    }
   93     93   
}
   94     94   
impl ProvisionedCapacityDescription {
   95     95   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   96         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   97         -
        deserializer: &mut D,
          96  +
    pub fn deserialize(
          97  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   98     98   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   99     99   
        #[allow(unused_variables, unused_mut)]
  100    100   
        let mut builder = Self::builder();
  101    101   
        #[allow(
  102    102   
            unused_variables,
  103    103   
            unreachable_code,
  104    104   
            clippy::single_match,
  105    105   
            clippy::match_single_binding,
  106    106   
            clippy::diverging_sub_expression
  107    107   
        )]
  108         -
        deserializer.read_struct(&PROVISIONEDCAPACITYDESCRIPTION_SCHEMA, (), |_, member, deser| {
         108  +
        deserializer.read_struct(&PROVISIONEDCAPACITYDESCRIPTION_SCHEMA, &mut |member, deser| {
  109    109   
            match member.member_index() {
  110    110   
                Some(0) => {
  111    111   
                    builder.capacity_id = Some(deser.read_string(member)?);
  112    112   
                }
  113    113   
                Some(1) => {
  114    114   
                    builder.start_date = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                Some(2) => {
  117    117   
                    builder.expiration_date = Some(deser.read_string(member)?);
  118    118   
                }
  119    119   
                _ => {}
  120    120   
            }
  121    121   
            Ok(())
  122    122   
        })?;
  123    123   
        Ok(builder.build())
  124    124   
    }
  125    125   
}
         126  +
impl ProvisionedCapacityDescription {
         127  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         128  +
    pub fn deserialize_with_response(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         130  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         131  +
        _status: u16,
         132  +
        _body: &[u8],
         133  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         134  +
        Self::deserialize(deserializer)
         135  +
    }
         136  +
}
  126    137   
impl ProvisionedCapacityDescription {
  127    138   
    /// Creates a new builder-style object to manufacture [`ProvisionedCapacityDescription`](crate::types::ProvisionedCapacityDescription).
  128    139   
    pub fn builder() -> crate::types::builders::ProvisionedCapacityDescriptionBuilder {
  129    140   
        crate::types::builders::ProvisionedCapacityDescriptionBuilder::default()
  130    141   
    }
  131    142   
}
  132    143   
  133    144   
/// A builder for [`ProvisionedCapacityDescription`](crate::types::ProvisionedCapacityDescription).
  134    145   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  135    146   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_s3_location.rs

@@ -35,35 +141,141 @@
   55     55   
    /// <p>The storage class used to store the job results.</p>
   56     56   
    pub fn storage_class(&self) -> ::std::option::Option<&crate::types::StorageClass> {
   57     57   
        self.storage_class.as_ref()
   58     58   
    }
   59     59   
}
   60     60   
static S3LOCATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   61     61   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location", "com.amazonaws.glacier", "S3Location");
   62     62   
static S3LOCATION_MEMBER_BUCKET_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$BucketName", "com.amazonaws.glacier", "S3Location"),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "bucket_name",
          65  +
    "BucketName",
   66     66   
    0,
   67     67   
);
   68     68   
static S3LOCATION_MEMBER_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$Prefix", "com.amazonaws.glacier", "S3Location"),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "prefix",
          71  +
    "Prefix",
   72     72   
    1,
   73     73   
);
   74     74   
static S3LOCATION_MEMBER_ENCRYPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$Encryption", "com.amazonaws.glacier", "S3Location"),
   76     76   
    ::aws_smithy_schema::ShapeType::Structure,
   77         -
    "encryption",
          77  +
    "Encryption",
   78     78   
    2,
   79     79   
);
   80     80   
static S3LOCATION_MEMBER_CANNED_ACL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$CannedACL", "com.amazonaws.glacier", "S3Location"),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "canned_acl",
          83  +
    "CannedACL",
   84     84   
    3,
   85     85   
);
   86     86   
static S3LOCATION_MEMBER_ACCESS_CONTROL_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.glacier#S3Location$AccessControlList",
   89     89   
        "com.amazonaws.glacier",
   90     90   
        "S3Location",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::List,
   93         -
    "access_control_list",
          93  +
    "AccessControlList",
   94     94   
    4,
   95     95   
);
   96     96   
static S3LOCATION_MEMBER_TAGGING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$Tagging", "com.amazonaws.glacier", "S3Location"),
   98     98   
    ::aws_smithy_schema::ShapeType::Map,
   99         -
    "tagging",
          99  +
    "Tagging",
  100    100   
    5,
  101    101   
);
  102    102   
static S3LOCATION_MEMBER_USER_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  103    103   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$UserMetadata", "com.amazonaws.glacier", "S3Location"),
  104    104   
    ::aws_smithy_schema::ShapeType::Map,
  105         -
    "user_metadata",
         105  +
    "UserMetadata",
  106    106   
    6,
  107    107   
);
  108    108   
static S3LOCATION_MEMBER_STORAGE_CLASS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#S3Location$StorageClass", "com.amazonaws.glacier", "S3Location"),
  110    110   
    ::aws_smithy_schema::ShapeType::String,
  111         -
    "storage_class",
         111  +
    "StorageClass",
  112    112   
    7,
  113    113   
);
  114    114   
static S3LOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  115    115   
    S3LOCATION_SCHEMA_ID,
  116    116   
    ::aws_smithy_schema::ShapeType::Structure,
  117    117   
    &[
  118    118   
        &S3LOCATION_MEMBER_BUCKET_NAME,
  119    119   
        &S3LOCATION_MEMBER_PREFIX,
  120    120   
        &S3LOCATION_MEMBER_ENCRYPTION,
  121    121   
        &S3LOCATION_MEMBER_CANNED_ACL,
@@ -163,163 +297,285 @@
  183    183   
            )?;
  184    184   
        }
  185    185   
        if let Some(ref val) = self.storage_class {
  186    186   
            ser.write_string(&S3LOCATION_MEMBER_STORAGE_CLASS, val.as_str())?;
  187    187   
        }
  188    188   
        Ok(())
  189    189   
    }
  190    190   
}
  191    191   
impl S3Location {
  192    192   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  193         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  194         -
        deserializer: &mut D,
         193  +
    pub fn deserialize(
         194  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  195    195   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  196    196   
        #[allow(unused_variables, unused_mut)]
  197    197   
        let mut builder = Self::builder();
  198    198   
        #[allow(
  199    199   
            unused_variables,
  200    200   
            unreachable_code,
  201    201   
            clippy::single_match,
  202    202   
            clippy::match_single_binding,
  203    203   
            clippy::diverging_sub_expression
  204    204   
        )]
  205         -
        deserializer.read_struct(&S3LOCATION_SCHEMA, (), |_, member, deser| {
         205  +
        deserializer.read_struct(&S3LOCATION_SCHEMA, &mut |member, deser| {
  206    206   
            match member.member_index() {
  207    207   
                Some(0) => {
  208    208   
                    builder.bucket_name = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(1) => {
  211    211   
                    builder.prefix = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(2) => {
  214    214   
                    builder.encryption = Some(crate::types::Encryption::deserialize(deser)?);
  215    215   
                }
  216    216   
                Some(3) => {
  217    217   
                    builder.canned_acl = Some(crate::types::CannedAcl::from(deser.read_string(member)?.as_str()));
  218    218   
                }
  219    219   
                Some(4) => {
  220    220   
                    builder.access_control_list = Some({
  221         -
                        let container = if let Some(cap) = deser.container_size() {
  222         -
                            Vec::with_capacity(cap)
  223         -
                        } else {
  224         -
                            Vec::new()
  225         -
                        };
  226         -
                        deser.read_list(member, container, |mut list, deser| {
  227         -
                            list.push(crate::types::Grant::deserialize(deser)?);
  228         -
                            Ok(list)
  229         -
                        })?
         221  +
                        let mut container = Vec::new();
         222  +
                        deser.read_list(member, &mut |deser| {
         223  +
                            container.push(crate::types::Grant::deserialize(deser)?);
         224  +
                            Ok(())
         225  +
                        })?;
         226  +
                        container
  230    227   
                    });
  231    228   
                }
  232    229   
                Some(5) => {
  233         -
                    builder.tagging = Some({
  234         -
                        let container = if let Some(cap) = deser.container_size() {
  235         -
                            std::collections::HashMap::with_capacity(cap)
  236         -
                        } else {
  237         -
                            std::collections::HashMap::new()
  238         -
                        };
  239         -
                        deser.read_map(member, container, |mut map, key, deser| {
  240         -
                            map.insert(key, deser.read_string(member)?);
  241         -
                            Ok(map)
  242         -
                        })?
  243         -
                    });
         230  +
                    builder.tagging = Some(deser.read_string_string_map(member)?);
  244    231   
                }
  245    232   
                Some(6) => {
  246         -
                    builder.user_metadata = Some({
  247         -
                        let container = if let Some(cap) = deser.container_size() {
  248         -
                            std::collections::HashMap::with_capacity(cap)
  249         -
                        } else {
  250         -
                            std::collections::HashMap::new()
  251         -
                        };
  252         -
                        deser.read_map(member, container, |mut map, key, deser| {
  253         -
                            map.insert(key, deser.read_string(member)?);
  254         -
                            Ok(map)
  255         -
                        })?
  256         -
                    });
         233  +
                    builder.user_metadata = Some(deser.read_string_string_map(member)?);
  257    234   
                }
  258    235   
                Some(7) => {
  259    236   
                    builder.storage_class = Some(crate::types::StorageClass::from(deser.read_string(member)?.as_str()));
  260    237   
                }
  261    238   
                _ => {}
  262    239   
            }
  263    240   
            Ok(())
  264    241   
        })?;
  265    242   
        Ok(builder.build())
  266    243   
    }
  267    244   
}
         245  +
impl S3Location {
         246  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         247  +
    pub fn deserialize_with_response(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         249  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         250  +
        _status: u16,
         251  +
        _body: &[u8],
         252  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         253  +
        Self::deserialize(deserializer)
         254  +
    }
         255  +
}
  268    256   
impl S3Location {
  269    257   
    /// Creates a new builder-style object to manufacture [`S3Location`](crate::types::S3Location).
  270    258   
    pub fn builder() -> crate::types::builders::S3LocationBuilder {
  271    259   
        crate::types::builders::S3LocationBuilder::default()
  272    260   
    }
  273    261   
}
  274    262   
  275    263   
/// A builder for [`S3Location`](crate::types::S3Location).
  276    264   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  277    265   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_select_parameters.rs

@@ -13,13 +175,186 @@
   33     33   
}
   34     34   
static SELECTPARAMETERS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#SelectParameters", "com.amazonaws.glacier", "SelectParameters");
   36     36   
static SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.glacier#SelectParameters$InputSerialization",
   39     39   
        "com.amazonaws.glacier",
   40     40   
        "SelectParameters",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43         -
    "input_serialization",
          43  +
    "InputSerialization",
   44     44   
    0,
   45     45   
);
   46     46   
static SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   47     47   
    ::aws_smithy_schema::ShapeId::from_static(
   48     48   
        "com.amazonaws.glacier#SelectParameters$ExpressionType",
   49     49   
        "com.amazonaws.glacier",
   50     50   
        "SelectParameters",
   51     51   
    ),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "expression_type",
          53  +
    "ExpressionType",
   54     54   
    1,
   55     55   
);
   56     56   
static SELECTPARAMETERS_MEMBER_EXPRESSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.glacier#SelectParameters$Expression",
   59     59   
        "com.amazonaws.glacier",
   60     60   
        "SelectParameters",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "expression",
          63  +
    "Expression",
   64     64   
    2,
   65     65   
);
   66     66   
static SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.glacier#SelectParameters$OutputSerialization",
   69     69   
        "com.amazonaws.glacier",
   70     70   
        "SelectParameters",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73         -
    "output_serialization",
          73  +
    "OutputSerialization",
   74     74   
    3,
   75     75   
);
   76     76   
static SELECTPARAMETERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   77     77   
    SELECTPARAMETERS_SCHEMA_ID,
   78     78   
    ::aws_smithy_schema::ShapeType::Structure,
   79     79   
    &[
   80     80   
        &SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION,
   81     81   
        &SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE,
   82     82   
        &SELECTPARAMETERS_MEMBER_EXPRESSION,
   83     83   
        &SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION,
   84     84   
    ],
   85     85   
);
   86     86   
impl SelectParameters {
   87     87   
    /// The schema for this shape.
   88     88   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SELECTPARAMETERS_SCHEMA;
   89     89   
}
   90     90   
impl ::aws_smithy_schema::serde::SerializableStruct for SelectParameters {
   91     91   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   92     92   
    fn serialize_members(
   93     93   
        &self,
   94     94   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   95     95   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   96     96   
        if let Some(ref val) = self.input_serialization {
   97     97   
            ser.write_struct(&SELECTPARAMETERS_MEMBER_INPUT_SERIALIZATION, val)?;
   98     98   
        }
   99     99   
        if let Some(ref val) = self.expression_type {
  100    100   
            ser.write_string(&SELECTPARAMETERS_MEMBER_EXPRESSION_TYPE, val.as_str())?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.expression {
  103    103   
            ser.write_string(&SELECTPARAMETERS_MEMBER_EXPRESSION, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.output_serialization {
  106    106   
            ser.write_struct(&SELECTPARAMETERS_MEMBER_OUTPUT_SERIALIZATION, val)?;
  107    107   
        }
  108    108   
        Ok(())
  109    109   
    }
  110    110   
}
  111    111   
impl SelectParameters {
  112    112   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  113         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  114         -
        deserializer: &mut D,
         113  +
    pub fn deserialize(
         114  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  115    115   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  116    116   
        #[allow(unused_variables, unused_mut)]
  117    117   
        let mut builder = Self::builder();
  118    118   
        #[allow(
  119    119   
            unused_variables,
  120    120   
            unreachable_code,
  121    121   
            clippy::single_match,
  122    122   
            clippy::match_single_binding,
  123    123   
            clippy::diverging_sub_expression
  124    124   
        )]
  125         -
        deserializer.read_struct(&SELECTPARAMETERS_SCHEMA, (), |_, member, deser| {
         125  +
        deserializer.read_struct(&SELECTPARAMETERS_SCHEMA, &mut |member, deser| {
  126    126   
            match member.member_index() {
  127    127   
                Some(0) => {
  128    128   
                    builder.input_serialization = Some(crate::types::InputSerialization::deserialize(deser)?);
  129    129   
                }
  130    130   
                Some(1) => {
  131    131   
                    builder.expression_type = Some(crate::types::ExpressionType::from(deser.read_string(member)?.as_str()));
  132    132   
                }
  133    133   
                Some(2) => {
  134    134   
                    builder.expression = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(3) => {
  137    137   
                    builder.output_serialization = Some(crate::types::OutputSerialization::deserialize(deser)?);
  138    138   
                }
  139    139   
                _ => {}
  140    140   
            }
  141    141   
            Ok(())
  142    142   
        })?;
  143    143   
        Ok(builder.build())
  144    144   
    }
  145    145   
}
         146  +
impl SelectParameters {
         147  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         148  +
    pub fn deserialize_with_response(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         150  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         151  +
        _status: u16,
         152  +
        _body: &[u8],
         153  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         154  +
        Self::deserialize(deserializer)
         155  +
    }
         156  +
}
  146    157   
impl SelectParameters {
  147    158   
    /// Creates a new builder-style object to manufacture [`SelectParameters`](crate::types::SelectParameters).
  148    159   
    pub fn builder() -> crate::types::builders::SelectParametersBuilder {
  149    160   
        crate::types::builders::SelectParametersBuilder::default()
  150    161   
    }
  151    162   
}
  152    163   
  153    164   
/// A builder for [`SelectParameters`](crate::types::SelectParameters).
  154    165   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  155    166   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_upload_list_element.rs

@@ -19,19 +199,210 @@
   39     39   
}
   40     40   
static UPLOADLISTELEMENT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   41     41   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#UploadListElement", "com.amazonaws.glacier", "UploadListElement");
   42     42   
static UPLOADLISTELEMENT_MEMBER_MULTIPART_UPLOAD_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.glacier#UploadListElement$MultipartUploadId",
   45     45   
        "com.amazonaws.glacier",
   46     46   
        "UploadListElement",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "multipart_upload_id",
          49  +
    "MultipartUploadId",
   50     50   
    0,
   51     51   
);
   52     52   
static UPLOADLISTELEMENT_MEMBER_VAULT_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.glacier#UploadListElement$VaultARN",
   55     55   
        "com.amazonaws.glacier",
   56     56   
        "UploadListElement",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "vault_arn",
          59  +
    "VaultARN",
   60     60   
    1,
   61     61   
);
   62     62   
static UPLOADLISTELEMENT_MEMBER_ARCHIVE_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   63     63   
    ::aws_smithy_schema::ShapeId::from_static(
   64     64   
        "com.amazonaws.glacier#UploadListElement$ArchiveDescription",
   65     65   
        "com.amazonaws.glacier",
   66     66   
        "UploadListElement",
   67     67   
    ),
   68     68   
    ::aws_smithy_schema::ShapeType::String,
   69         -
    "archive_description",
          69  +
    "ArchiveDescription",
   70     70   
    2,
   71     71   
);
   72     72   
static UPLOADLISTELEMENT_MEMBER_PART_SIZE_IN_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.glacier#UploadListElement$PartSizeInBytes",
   75     75   
        "com.amazonaws.glacier",
   76     76   
        "UploadListElement",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Long,
   79         -
    "part_size_in_bytes",
          79  +
    "PartSizeInBytes",
   80     80   
    3,
   81     81   
);
   82     82   
static UPLOADLISTELEMENT_MEMBER_CREATION_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.glacier#UploadListElement$CreationDate",
   85     85   
        "com.amazonaws.glacier",
   86     86   
        "UploadListElement",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::String,
   89         -
    "creation_date",
          89  +
    "CreationDate",
   90     90   
    4,
   91     91   
);
   92     92   
static UPLOADLISTELEMENT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   93     93   
    UPLOADLISTELEMENT_SCHEMA_ID,
   94     94   
    ::aws_smithy_schema::ShapeType::Structure,
   95     95   
    &[
   96     96   
        &UPLOADLISTELEMENT_MEMBER_MULTIPART_UPLOAD_ID,
   97     97   
        &UPLOADLISTELEMENT_MEMBER_VAULT_ARN,
   98     98   
        &UPLOADLISTELEMENT_MEMBER_ARCHIVE_DESCRIPTION,
   99     99   
        &UPLOADLISTELEMENT_MEMBER_PART_SIZE_IN_BYTES,
  100    100   
        &UPLOADLISTELEMENT_MEMBER_CREATION_DATE,
  101    101   
    ],
  102    102   
);
  103    103   
impl UploadListElement {
  104    104   
    /// The schema for this shape.
  105    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &UPLOADLISTELEMENT_SCHEMA;
  106    106   
}
  107    107   
impl ::aws_smithy_schema::serde::SerializableStruct for UploadListElement {
  108    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  109    109   
    fn serialize_members(
  110    110   
        &self,
  111    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  112    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  113    113   
        if let Some(ref val) = self.multipart_upload_id {
  114    114   
            ser.write_string(&UPLOADLISTELEMENT_MEMBER_MULTIPART_UPLOAD_ID, val)?;
  115    115   
        }
  116    116   
        if let Some(ref val) = self.vault_arn {
  117    117   
            ser.write_string(&UPLOADLISTELEMENT_MEMBER_VAULT_ARN, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.archive_description {
  120    120   
            ser.write_string(&UPLOADLISTELEMENT_MEMBER_ARCHIVE_DESCRIPTION, val)?;
  121    121   
        }
  122    122   
        {
  123    123   
            let val = &self.part_size_in_bytes;
  124    124   
            ser.write_long(&UPLOADLISTELEMENT_MEMBER_PART_SIZE_IN_BYTES, *val)?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.creation_date {
  127    127   
            ser.write_string(&UPLOADLISTELEMENT_MEMBER_CREATION_DATE, val)?;
  128    128   
        }
  129    129   
        Ok(())
  130    130   
    }
  131    131   
}
  132    132   
impl UploadListElement {
  133    133   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  134         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  135         -
        deserializer: &mut D,
         134  +
    pub fn deserialize(
         135  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  136    136   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  137    137   
        #[allow(unused_variables, unused_mut)]
  138    138   
        let mut builder = Self::builder();
  139    139   
        #[allow(
  140    140   
            unused_variables,
  141    141   
            unreachable_code,
  142    142   
            clippy::single_match,
  143    143   
            clippy::match_single_binding,
  144    144   
            clippy::diverging_sub_expression
  145    145   
        )]
  146         -
        deserializer.read_struct(&UPLOADLISTELEMENT_SCHEMA, (), |_, member, deser| {
         146  +
        deserializer.read_struct(&UPLOADLISTELEMENT_SCHEMA, &mut |member, deser| {
  147    147   
            match member.member_index() {
  148    148   
                Some(0) => {
  149    149   
                    builder.multipart_upload_id = Some(deser.read_string(member)?);
  150    150   
                }
  151    151   
                Some(1) => {
  152    152   
                    builder.vault_arn = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                Some(2) => {
  155    155   
                    builder.archive_description = Some(deser.read_string(member)?);
  156    156   
                }
  157    157   
                Some(3) => {
  158    158   
                    builder.part_size_in_bytes = Some(deser.read_long(member)?);
  159    159   
                }
  160    160   
                Some(4) => {
  161    161   
                    builder.creation_date = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                _ => {}
  164    164   
            }
  165    165   
            Ok(())
  166    166   
        })?;
  167    167   
        Ok(builder.build())
  168    168   
    }
  169    169   
}
         170  +
impl UploadListElement {
         171  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         172  +
    pub fn deserialize_with_response(
         173  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         174  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         175  +
        _status: u16,
         176  +
        _body: &[u8],
         177  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         178  +
        Self::deserialize(deserializer)
         179  +
    }
         180  +
}
  170    181   
impl UploadListElement {
  171    182   
    /// Creates a new builder-style object to manufacture [`UploadListElement`](crate::types::UploadListElement).
  172    183   
    pub fn builder() -> crate::types::builders::UploadListElementBuilder {
  173    184   
        crate::types::builders::UploadListElementBuilder::default()
  174    185   
    }
  175    186   
}
  176    187   
  177    188   
/// A builder for [`UploadListElement`](crate::types::UploadListElement).
  178    189   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    190   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_vault_access_policy.rs

@@ -1,1 +104,115 @@
   15     15   
}
   16     16   
static VAULTACCESSPOLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#VaultAccessPolicy", "com.amazonaws.glacier", "VaultAccessPolicy");
   18     18   
static VAULTACCESSPOLICY_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static(
   20     20   
        "com.amazonaws.glacier#VaultAccessPolicy$Policy",
   21     21   
        "com.amazonaws.glacier",
   22     22   
        "VaultAccessPolicy",
   23     23   
    ),
   24     24   
    ::aws_smithy_schema::ShapeType::String,
   25         -
    "policy",
          25  +
    "Policy",
   26     26   
    0,
   27     27   
);
   28     28   
static VAULTACCESSPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   29     29   
    VAULTACCESSPOLICY_SCHEMA_ID,
   30     30   
    ::aws_smithy_schema::ShapeType::Structure,
   31     31   
    &[&VAULTACCESSPOLICY_MEMBER_POLICY],
   32     32   
);
   33     33   
impl VaultAccessPolicy {
   34     34   
    /// The schema for this shape.
   35     35   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VAULTACCESSPOLICY_SCHEMA;
   36     36   
}
   37     37   
impl ::aws_smithy_schema::serde::SerializableStruct for VaultAccessPolicy {
   38     38   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   39     39   
    fn serialize_members(
   40     40   
        &self,
   41     41   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   42     42   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   43     43   
        if let Some(ref val) = self.policy {
   44     44   
            ser.write_string(&VAULTACCESSPOLICY_MEMBER_POLICY, val)?;
   45     45   
        }
   46     46   
        Ok(())
   47     47   
    }
   48     48   
}
   49     49   
impl VaultAccessPolicy {
   50     50   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   51         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   52         -
        deserializer: &mut D,
          51  +
    pub fn deserialize(
          52  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   53     53   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   54     54   
        #[allow(unused_variables, unused_mut)]
   55     55   
        let mut builder = Self::builder();
   56     56   
        #[allow(
   57     57   
            unused_variables,
   58     58   
            unreachable_code,
   59     59   
            clippy::single_match,
   60     60   
            clippy::match_single_binding,
   61     61   
            clippy::diverging_sub_expression
   62     62   
        )]
   63         -
        deserializer.read_struct(&VAULTACCESSPOLICY_SCHEMA, (), |_, member, deser| {
          63  +
        deserializer.read_struct(&VAULTACCESSPOLICY_SCHEMA, &mut |member, deser| {
   64     64   
            match member.member_index() {
   65     65   
                Some(0) => {
   66     66   
                    builder.policy = Some(deser.read_string(member)?);
   67     67   
                }
   68     68   
                _ => {}
   69     69   
            }
   70     70   
            Ok(())
   71     71   
        })?;
   72     72   
        Ok(builder.build())
   73     73   
    }
   74     74   
}
          75  +
impl VaultAccessPolicy {
          76  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          77  +
    pub fn deserialize_with_response(
          78  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          79  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          80  +
        _status: u16,
          81  +
        _body: &[u8],
          82  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          83  +
        Self::deserialize(deserializer)
          84  +
    }
          85  +
}
   75     86   
impl VaultAccessPolicy {
   76     87   
    /// Creates a new builder-style object to manufacture [`VaultAccessPolicy`](crate::types::VaultAccessPolicy).
   77     88   
    pub fn builder() -> crate::types::builders::VaultAccessPolicyBuilder {
   78     89   
        crate::types::builders::VaultAccessPolicyBuilder::default()
   79     90   
    }
   80     91   
}
   81     92   
   82     93   
/// A builder for [`VaultAccessPolicy`](crate::types::VaultAccessPolicy).
   83     94   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   84     95   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_vault_lock_policy.rs

@@ -1,1 +100,111 @@
   11     11   
    /// <p>The vault lock policy.</p>
   12     12   
    pub fn policy(&self) -> ::std::option::Option<&str> {
   13     13   
        self.policy.as_deref()
   14     14   
    }
   15     15   
}
   16     16   
static VAULTLOCKPOLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   17     17   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#VaultLockPolicy", "com.amazonaws.glacier", "VaultLockPolicy");
   18     18   
static VAULTLOCKPOLICY_MEMBER_POLICY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   19     19   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.glacier#VaultLockPolicy$Policy", "com.amazonaws.glacier", "VaultLockPolicy"),
   20     20   
    ::aws_smithy_schema::ShapeType::String,
   21         -
    "policy",
          21  +
    "Policy",
   22     22   
    0,
   23     23   
);
   24     24   
static VAULTLOCKPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   25     25   
    VAULTLOCKPOLICY_SCHEMA_ID,
   26     26   
    ::aws_smithy_schema::ShapeType::Structure,
   27     27   
    &[&VAULTLOCKPOLICY_MEMBER_POLICY],
   28     28   
);
   29     29   
impl VaultLockPolicy {
   30     30   
    /// The schema for this shape.
   31     31   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VAULTLOCKPOLICY_SCHEMA;
   32     32   
}
   33     33   
impl ::aws_smithy_schema::serde::SerializableStruct for VaultLockPolicy {
   34     34   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   35     35   
    fn serialize_members(
   36     36   
        &self,
   37     37   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   38     38   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   39     39   
        if let Some(ref val) = self.policy {
   40     40   
            ser.write_string(&VAULTLOCKPOLICY_MEMBER_POLICY, val)?;
   41     41   
        }
   42     42   
        Ok(())
   43     43   
    }
   44     44   
}
   45     45   
impl VaultLockPolicy {
   46     46   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   47         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   48         -
        deserializer: &mut D,
          47  +
    pub fn deserialize(
          48  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   49     49   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   50     50   
        #[allow(unused_variables, unused_mut)]
   51     51   
        let mut builder = Self::builder();
   52     52   
        #[allow(
   53     53   
            unused_variables,
   54     54   
            unreachable_code,
   55     55   
            clippy::single_match,
   56     56   
            clippy::match_single_binding,
   57     57   
            clippy::diverging_sub_expression
   58     58   
        )]
   59         -
        deserializer.read_struct(&VAULTLOCKPOLICY_SCHEMA, (), |_, member, deser| {
          59  +
        deserializer.read_struct(&VAULTLOCKPOLICY_SCHEMA, &mut |member, deser| {
   60     60   
            match member.member_index() {
   61     61   
                Some(0) => {
   62     62   
                    builder.policy = Some(deser.read_string(member)?);
   63     63   
                }
   64     64   
                _ => {}
   65     65   
            }
   66     66   
            Ok(())
   67     67   
        })?;
   68     68   
        Ok(builder.build())
   69     69   
    }
   70     70   
}
          71  +
impl VaultLockPolicy {
          72  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          73  +
    pub fn deserialize_with_response(
          74  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          75  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          76  +
        _status: u16,
          77  +
        _body: &[u8],
          78  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          79  +
        Self::deserialize(deserializer)
          80  +
    }
          81  +
}
   71     82   
impl VaultLockPolicy {
   72     83   
    /// Creates a new builder-style object to manufacture [`VaultLockPolicy`](crate::types::VaultLockPolicy).
   73     84   
    pub fn builder() -> crate::types::builders::VaultLockPolicyBuilder {
   74     85   
        crate::types::builders::VaultLockPolicyBuilder::default()
   75     86   
    }
   76     87   
}
   77     88   
   78     89   
/// A builder for [`VaultLockPolicy`](crate::types::VaultLockPolicy).
   79     90   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   80     91   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/_vault_notification_config.rs

@@ -6,6 +149,150 @@
   26     26   
    "com.amazonaws.glacier",
   27     27   
    "VaultNotificationConfig",
   28     28   
);
   29     29   
static VAULTNOTIFICATIONCONFIG_MEMBER_SNS_TOPIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   30     30   
    ::aws_smithy_schema::ShapeId::from_static(
   31     31   
        "com.amazonaws.glacier#VaultNotificationConfig$SNSTopic",
   32     32   
        "com.amazonaws.glacier",
   33     33   
        "VaultNotificationConfig",
   34     34   
    ),
   35     35   
    ::aws_smithy_schema::ShapeType::String,
   36         -
    "sns_topic",
          36  +
    "SNSTopic",
   37     37   
    0,
   38     38   
);
   39     39   
static VAULTNOTIFICATIONCONFIG_MEMBER_EVENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.glacier#VaultNotificationConfig$Events",
   42     42   
        "com.amazonaws.glacier",
   43     43   
        "VaultNotificationConfig",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::List,
   46         -
    "events",
          46  +
    "Events",
   47     47   
    1,
   48     48   
);
   49     49   
static VAULTNOTIFICATIONCONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   50     50   
    VAULTNOTIFICATIONCONFIG_SCHEMA_ID,
   51     51   
    ::aws_smithy_schema::ShapeType::Structure,
   52     52   
    &[&VAULTNOTIFICATIONCONFIG_MEMBER_SNS_TOPIC, &VAULTNOTIFICATIONCONFIG_MEMBER_EVENTS],
   53     53   
);
   54     54   
impl VaultNotificationConfig {
   55     55   
    /// The schema for this shape.
   56     56   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &VAULTNOTIFICATIONCONFIG_SCHEMA;
   57     57   
}
   58     58   
impl ::aws_smithy_schema::serde::SerializableStruct for VaultNotificationConfig {
   59     59   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   60     60   
    fn serialize_members(
   61     61   
        &self,
   62     62   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   63     63   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   64     64   
        if let Some(ref val) = self.sns_topic {
   65     65   
            ser.write_string(&VAULTNOTIFICATIONCONFIG_MEMBER_SNS_TOPIC, val)?;
   66     66   
        }
   67     67   
        if let Some(ref val) = self.events {
   68     68   
            ser.write_list(
   69     69   
                &VAULTNOTIFICATIONCONFIG_MEMBER_EVENTS,
   70     70   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   71     71   
                    for item in val {
   72     72   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   73     73   
                    }
   74     74   
                    Ok(())
   75     75   
                },
   76     76   
            )?;
   77     77   
        }
   78     78   
        Ok(())
   79     79   
    }
   80     80   
}
   81     81   
impl VaultNotificationConfig {
   82     82   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   83         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   84         -
        deserializer: &mut D,
          83  +
    pub fn deserialize(
          84  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   85     85   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   86     86   
        #[allow(unused_variables, unused_mut)]
   87     87   
        let mut builder = Self::builder();
   88     88   
        #[allow(
   89     89   
            unused_variables,
   90     90   
            unreachable_code,
   91     91   
            clippy::single_match,
   92     92   
            clippy::match_single_binding,
   93     93   
            clippy::diverging_sub_expression
   94     94   
        )]
   95         -
        deserializer.read_struct(&VAULTNOTIFICATIONCONFIG_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&VAULTNOTIFICATIONCONFIG_SCHEMA, &mut |member, deser| {
   96     96   
            match member.member_index() {
   97     97   
                Some(0) => {
   98     98   
                    builder.sns_topic = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                Some(1) => {
  101         -
                    builder.events = Some({
  102         -
                        let container = if let Some(cap) = deser.container_size() {
  103         -
                            Vec::with_capacity(cap)
  104         -
                        } else {
  105         -
                            Vec::new()
  106         -
                        };
  107         -
                        deser.read_list(member, container, |mut list, deser| {
  108         -
                            list.push(deser.read_string(member)?);
  109         -
                            Ok(list)
  110         -
                        })?
  111         -
                    });
         101  +
                    builder.events = Some(deser.read_string_list(member)?);
  112    102   
                }
  113    103   
                _ => {}
  114    104   
            }
  115    105   
            Ok(())
  116    106   
        })?;
  117    107   
        Ok(builder.build())
  118    108   
    }
  119    109   
}
         110  +
impl VaultNotificationConfig {
         111  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         112  +
    pub fn deserialize_with_response(
         113  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         114  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         115  +
        _status: u16,
         116  +
        _body: &[u8],
         117  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         118  +
        Self::deserialize(deserializer)
         119  +
    }
         120  +
}
  120    121   
impl VaultNotificationConfig {
  121    122   
    /// Creates a new builder-style object to manufacture [`VaultNotificationConfig`](crate::types::VaultNotificationConfig).
  122    123   
    pub fn builder() -> crate::types::builders::VaultNotificationConfigBuilder {
  123    124   
        crate::types::builders::VaultNotificationConfigBuilder::default()
  124    125   
    }
  125    126   
}
  126    127   
  127    128   
/// A builder for [`VaultNotificationConfig`](crate::types::VaultNotificationConfig).
  128    129   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  129    130   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/error/_insufficient_capacity_exception.rs

@@ -7,7 +152,163 @@
   27     27   
    "com.amazonaws.glacier",
   28     28   
    "InsufficientCapacityException",
   29     29   
);
   30     30   
static INSUFFICIENTCAPACITYEXCEPTION_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.glacier#InsufficientCapacityException$type",
   33     33   
        "com.amazonaws.glacier",
   34     34   
        "InsufficientCapacityException",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::String,
   37         -
    "r##type",
          37  +
    "type",
   38     38   
    0,
   39     39   
);
   40     40   
static INSUFFICIENTCAPACITYEXCEPTION_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.glacier#InsufficientCapacityException$code",
   43     43   
        "com.amazonaws.glacier",
   44     44   
        "InsufficientCapacityException",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47     47   
    "code",
   48     48   
    1,
   49     49   
);
   50     50   
static INSUFFICIENTCAPACITYEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.glacier#InsufficientCapacityException$message",
   53     53   
        "com.amazonaws.glacier",
   54     54   
        "InsufficientCapacityException",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57     57   
    "message",
   58     58   
    2,
   59     59   
);
   60     60   
static INSUFFICIENTCAPACITYEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   61     61   
    INSUFFICIENTCAPACITYEXCEPTION_SCHEMA_ID,
   62     62   
    ::aws_smithy_schema::ShapeType::Structure,
   63     63   
    &[
   64     64   
        &INSUFFICIENTCAPACITYEXCEPTION_MEMBER_TYPE,
   65     65   
        &INSUFFICIENTCAPACITYEXCEPTION_MEMBER_CODE,
   66     66   
        &INSUFFICIENTCAPACITYEXCEPTION_MEMBER_MESSAGE,
   67     67   
    ],
   68     68   
);
   69     69   
impl InsufficientCapacityException {
   70     70   
    /// The schema for this shape.
   71     71   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INSUFFICIENTCAPACITYEXCEPTION_SCHEMA;
   72     72   
}
   73     73   
impl ::aws_smithy_schema::serde::SerializableStruct for InsufficientCapacityException {
   74     74   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   75     75   
    fn serialize_members(
   76     76   
        &self,
   77     77   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   78     78   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        if let Some(ref val) = self.r#type {
   80     80   
            ser.write_string(&INSUFFICIENTCAPACITYEXCEPTION_MEMBER_TYPE, val)?;
   81     81   
        }
   82     82   
        if let Some(ref val) = self.code {
   83     83   
            ser.write_string(&INSUFFICIENTCAPACITYEXCEPTION_MEMBER_CODE, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.message {
   86     86   
            ser.write_string(&INSUFFICIENTCAPACITYEXCEPTION_MEMBER_MESSAGE, val)?;
   87     87   
        }
   88     88   
        Ok(())
   89     89   
    }
   90     90   
}
   91     91   
impl InsufficientCapacityException {
   92     92   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   93         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   94         -
        deserializer: &mut D,
          93  +
    pub fn deserialize(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   95     95   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   96     96   
        #[allow(unused_variables, unused_mut)]
   97     97   
        let mut builder = Self::builder();
   98     98   
        #[allow(
   99     99   
            unused_variables,
  100    100   
            unreachable_code,
  101    101   
            clippy::single_match,
  102    102   
            clippy::match_single_binding,
  103    103   
            clippy::diverging_sub_expression
  104    104   
        )]
  105         -
        deserializer.read_struct(&INSUFFICIENTCAPACITYEXCEPTION_SCHEMA, (), |_, member, deser| {
         105  +
        deserializer.read_struct(&INSUFFICIENTCAPACITYEXCEPTION_SCHEMA, &mut |member, deser| {
  106    106   
            match member.member_index() {
  107    107   
                Some(0) => {
  108    108   
                    builder.r#type = Some(deser.read_string(member)?);
  109    109   
                }
  110    110   
                Some(1) => {
  111    111   
                    builder.code = Some(deser.read_string(member)?);
  112    112   
                }
  113    113   
                Some(2) => {
  114    114   
                    builder.message = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                _ => {}
  117    117   
            }
  118    118   
            Ok(())
  119    119   
        })?;
  120    120   
        Ok(builder.build())
  121    121   
    }
  122    122   
}
         123  +
impl InsufficientCapacityException {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
  123    134   
impl InsufficientCapacityException {
  124    135   
    /// Returns the error message.
  125    136   
    pub fn message(&self) -> ::std::option::Option<&str> {
  126    137   
        self.message.as_deref()
  127    138   
    }
  128    139   
}
  129    140   
impl ::std::fmt::Display for InsufficientCapacityException {
  130    141   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  131    142   
        ::std::write!(f, "InsufficientCapacityException")?;
  132    143   
        if let ::std::option::Option::Some(inner_1) = &self.message {

tmp-codegen-diff/aws-sdk/sdk/glacier/src/types/error/_invalid_parameter_value_exception.rs

@@ -7,7 +152,163 @@
   27     27   
    "com.amazonaws.glacier",
   28     28   
    "InvalidParameterValueException",
   29     29   
);
   30     30   
static INVALIDPARAMETERVALUEEXCEPTION_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static(
   32     32   
        "com.amazonaws.glacier#InvalidParameterValueException$type",
   33     33   
        "com.amazonaws.glacier",
   34     34   
        "InvalidParameterValueException",
   35     35   
    ),
   36     36   
    ::aws_smithy_schema::ShapeType::String,
   37         -
    "r##type",
          37  +
    "type",
   38     38   
    0,
   39     39   
);
   40     40   
static INVALIDPARAMETERVALUEEXCEPTION_MEMBER_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.glacier#InvalidParameterValueException$code",
   43     43   
        "com.amazonaws.glacier",
   44     44   
        "InvalidParameterValueException",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47     47   
    "code",
   48     48   
    1,
   49     49   
);
   50     50   
static INVALIDPARAMETERVALUEEXCEPTION_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static(
   52     52   
        "com.amazonaws.glacier#InvalidParameterValueException$message",
   53     53   
        "com.amazonaws.glacier",
   54     54   
        "InvalidParameterValueException",
   55     55   
    ),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57     57   
    "message",
   58     58   
    2,
   59     59   
);
   60     60   
static INVALIDPARAMETERVALUEEXCEPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   61     61   
    INVALIDPARAMETERVALUEEXCEPTION_SCHEMA_ID,
   62     62   
    ::aws_smithy_schema::ShapeType::Structure,
   63     63   
    &[
   64     64   
        &INVALIDPARAMETERVALUEEXCEPTION_MEMBER_TYPE,
   65     65   
        &INVALIDPARAMETERVALUEEXCEPTION_MEMBER_CODE,
   66     66   
        &INVALIDPARAMETERVALUEEXCEPTION_MEMBER_MESSAGE,
   67     67   
    ],
   68     68   
);
   69     69   
impl InvalidParameterValueException {
   70     70   
    /// The schema for this shape.
   71     71   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &INVALIDPARAMETERVALUEEXCEPTION_SCHEMA;
   72     72   
}
   73     73   
impl ::aws_smithy_schema::serde::SerializableStruct for InvalidParameterValueException {
   74     74   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   75     75   
    fn serialize_members(
   76     76   
        &self,
   77     77   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   78     78   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        if let Some(ref val) = self.r#type {
   80     80   
            ser.write_string(&INVALIDPARAMETERVALUEEXCEPTION_MEMBER_TYPE, val)?;
   81     81   
        }
   82     82   
        if let Some(ref val) = self.code {
   83     83   
            ser.write_string(&INVALIDPARAMETERVALUEEXCEPTION_MEMBER_CODE, val)?;
   84     84   
        }
   85     85   
        if let Some(ref val) = self.message {
   86     86   
            ser.write_string(&INVALIDPARAMETERVALUEEXCEPTION_MEMBER_MESSAGE, val)?;
   87     87   
        }
   88     88   
        Ok(())
   89     89   
    }
   90     90   
}
   91     91   
impl InvalidParameterValueException {
   92     92   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   93         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   94         -
        deserializer: &mut D,
          93  +
    pub fn deserialize(
          94  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   95     95   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   96     96   
        #[allow(unused_variables, unused_mut)]
   97     97   
        let mut builder = Self::builder();
   98     98   
        #[allow(
   99     99   
            unused_variables,
  100    100   
            unreachable_code,
  101    101   
            clippy::single_match,
  102    102   
            clippy::match_single_binding,
  103    103   
            clippy::diverging_sub_expression
  104    104   
        )]
  105         -
        deserializer.read_struct(&INVALIDPARAMETERVALUEEXCEPTION_SCHEMA, (), |_, member, deser| {
         105  +
        deserializer.read_struct(&INVALIDPARAMETERVALUEEXCEPTION_SCHEMA, &mut |member, deser| {
  106    106   
            match member.member_index() {
  107    107   
                Some(0) => {
  108    108   
                    builder.r#type = Some(deser.read_string(member)?);
  109    109   
                }
  110    110   
                Some(1) => {
  111    111   
                    builder.code = Some(deser.read_string(member)?);
  112    112   
                }
  113    113   
                Some(2) => {
  114    114   
                    builder.message = Some(deser.read_string(member)?);
  115    115   
                }
  116    116   
                _ => {}
  117    117   
            }
  118    118   
            Ok(())
  119    119   
        })?;
  120    120   
        Ok(builder.build())
  121    121   
    }
  122    122   
}
         123  +
impl InvalidParameterValueException {
         124  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         125  +
    pub fn deserialize_with_response(
         126  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         127  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         128  +
        _status: u16,
         129  +
        _body: &[u8],
         130  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         131  +
        Self::deserialize(deserializer)
         132  +
    }
         133  +
}
  123    134   
impl InvalidParameterValueException {
  124    135   
    /// Returns the error message.
  125    136   
    pub fn message(&self) -> ::std::option::Option<&str> {
  126    137   
        self.message.as_deref()
  127    138   
    }
  128    139   
}
  129    140   
impl ::std::fmt::Display for InvalidParameterValueException {
  130    141   
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  131    142   
        ::std::write!(f, "InvalidParameterValueException")?;
  132    143   
        if let ::std::option::Option::Some(inner_1) = &self.message {