AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_filters.rs

@@ -16,16 +178,189 @@
   36     36   
    "com.amazonaws.configservice",
   37     37   
    "ResourceFilters",
   38     38   
);
   39     39   
static RESOURCEFILTERS_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#ResourceFilters$AccountId",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "ResourceFilters",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "account_id",
          46  +
    "AccountId",
   47     47   
    0,
   48     48   
);
   49     49   
static RESOURCEFILTERS_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.configservice#ResourceFilters$ResourceId",
   52     52   
        "com.amazonaws.configservice",
   53     53   
        "ResourceFilters",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "resource_id",
          56  +
    "ResourceId",
   57     57   
    1,
   58     58   
);
   59     59   
static RESOURCEFILTERS_MEMBER_RESOURCE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.configservice#ResourceFilters$ResourceName",
   62     62   
        "com.amazonaws.configservice",
   63     63   
        "ResourceFilters",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "resource_name",
          66  +
    "ResourceName",
   67     67   
    2,
   68     68   
);
   69     69   
static RESOURCEFILTERS_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.configservice#ResourceFilters$Region",
   72     72   
        "com.amazonaws.configservice",
   73     73   
        "ResourceFilters",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "region",
          76  +
    "Region",
   77     77   
    3,
   78     78   
);
   79     79   
static RESOURCEFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    RESOURCEFILTERS_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &RESOURCEFILTERS_MEMBER_ACCOUNT_ID,
   84     84   
        &RESOURCEFILTERS_MEMBER_RESOURCE_ID,
   85     85   
        &RESOURCEFILTERS_MEMBER_RESOURCE_NAME,
   86     86   
        &RESOURCEFILTERS_MEMBER_REGION,
   87     87   
    ],
   88     88   
);
   89     89   
impl ResourceFilters {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEFILTERS_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceFilters {
   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.account_id {
  100    100   
            ser.write_string(&RESOURCEFILTERS_MEMBER_ACCOUNT_ID, val)?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.resource_id {
  103    103   
            ser.write_string(&RESOURCEFILTERS_MEMBER_RESOURCE_ID, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.resource_name {
  106    106   
            ser.write_string(&RESOURCEFILTERS_MEMBER_RESOURCE_NAME, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.region {
  109    109   
            ser.write_string(&RESOURCEFILTERS_MEMBER_REGION, val)?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl ResourceFilters {
  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(&RESOURCEFILTERS_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&RESOURCEFILTERS_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.account_id = Some(deser.read_string(member)?);
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.resource_id = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.resource_name = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.region = 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 ResourceFilters {
         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 ResourceFilters {
  150    161   
    /// Creates a new builder-style object to manufacture [`ResourceFilters`](crate::types::ResourceFilters).
  151    162   
    pub fn builder() -> crate::types::builders::ResourceFiltersBuilder {
  152    163   
        crate::types::builders::ResourceFiltersBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`ResourceFilters`](crate::types::ResourceFilters).
  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/config/src/types/_resource_identifier.rs

@@ -16,16 +178,189 @@
   36     36   
    "com.amazonaws.configservice",
   37     37   
    "ResourceIdentifier",
   38     38   
);
   39     39   
static RESOURCEIDENTIFIER_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.configservice#ResourceIdentifier$resourceType",
   42     42   
        "com.amazonaws.configservice",
   43     43   
        "ResourceIdentifier",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "resource_type",
          46  +
    "resourceType",
   47     47   
    0,
   48     48   
);
   49     49   
static RESOURCEIDENTIFIER_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.configservice#ResourceIdentifier$resourceId",
   52     52   
        "com.amazonaws.configservice",
   53     53   
        "ResourceIdentifier",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "resource_id",
          56  +
    "resourceId",
   57     57   
    1,
   58     58   
);
   59     59   
static RESOURCEIDENTIFIER_MEMBER_RESOURCE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.configservice#ResourceIdentifier$resourceName",
   62     62   
        "com.amazonaws.configservice",
   63     63   
        "ResourceIdentifier",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "resource_name",
          66  +
    "resourceName",
   67     67   
    2,
   68     68   
);
   69     69   
static RESOURCEIDENTIFIER_MEMBER_RESOURCE_DELETION_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.configservice#ResourceIdentifier$resourceDeletionTime",
   72     72   
        "com.amazonaws.configservice",
   73     73   
        "ResourceIdentifier",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Timestamp,
   76         -
    "resource_deletion_time",
          76  +
    "resourceDeletionTime",
   77     77   
    3,
   78     78   
);
   79     79   
static RESOURCEIDENTIFIER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   80     80   
    RESOURCEIDENTIFIER_SCHEMA_ID,
   81     81   
    ::aws_smithy_schema::ShapeType::Structure,
   82     82   
    &[
   83     83   
        &RESOURCEIDENTIFIER_MEMBER_RESOURCE_TYPE,
   84     84   
        &RESOURCEIDENTIFIER_MEMBER_RESOURCE_ID,
   85     85   
        &RESOURCEIDENTIFIER_MEMBER_RESOURCE_NAME,
   86     86   
        &RESOURCEIDENTIFIER_MEMBER_RESOURCE_DELETION_TIME,
   87     87   
    ],
   88     88   
);
   89     89   
impl ResourceIdentifier {
   90     90   
    /// The schema for this shape.
   91     91   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCEIDENTIFIER_SCHEMA;
   92     92   
}
   93     93   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceIdentifier {
   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.resource_type {
  100    100   
            ser.write_string(&RESOURCEIDENTIFIER_MEMBER_RESOURCE_TYPE, val.as_str())?;
  101    101   
        }
  102    102   
        if let Some(ref val) = self.resource_id {
  103    103   
            ser.write_string(&RESOURCEIDENTIFIER_MEMBER_RESOURCE_ID, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.resource_name {
  106    106   
            ser.write_string(&RESOURCEIDENTIFIER_MEMBER_RESOURCE_NAME, val)?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.resource_deletion_time {
  109    109   
            ser.write_timestamp(&RESOURCEIDENTIFIER_MEMBER_RESOURCE_DELETION_TIME, val)?;
  110    110   
        }
  111    111   
        Ok(())
  112    112   
    }
  113    113   
}
  114    114   
impl ResourceIdentifier {
  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(&RESOURCEIDENTIFIER_SCHEMA, (), |_, member, deser| {
         128  +
        deserializer.read_struct(&RESOURCEIDENTIFIER_SCHEMA, &mut |member, deser| {
  129    129   
            match member.member_index() {
  130    130   
                Some(0) => {
  131    131   
                    builder.resource_type = Some(crate::types::ResourceType::from(deser.read_string(member)?.as_str()));
  132    132   
                }
  133    133   
                Some(1) => {
  134    134   
                    builder.resource_id = Some(deser.read_string(member)?);
  135    135   
                }
  136    136   
                Some(2) => {
  137    137   
                    builder.resource_name = Some(deser.read_string(member)?);
  138    138   
                }
  139    139   
                Some(3) => {
  140    140   
                    builder.resource_deletion_time = Some(deser.read_timestamp(member)?);
  141    141   
                }
  142    142   
                _ => {}
  143    143   
            }
  144    144   
            Ok(())
  145    145   
        })?;
  146    146   
        Ok(builder.build())
  147    147   
    }
  148    148   
}
         149  +
impl ResourceIdentifier {
         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 ResourceIdentifier {
  150    161   
    /// Creates a new builder-style object to manufacture [`ResourceIdentifier`](crate::types::ResourceIdentifier).
  151    162   
    pub fn builder() -> crate::types::builders::ResourceIdentifierBuilder {
  152    163   
        crate::types::builders::ResourceIdentifierBuilder::default()
  153    164   
    }
  154    165   
}
  155    166   
  156    167   
/// A builder for [`ResourceIdentifier`](crate::types::ResourceIdentifier).
  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/config/src/types/_resource_key.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_resource_value.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_retention_configuration.rs

@@ -9,9 +141,154 @@
   29     29   
    "com.amazonaws.configservice",
   30     30   
    "RetentionConfiguration",
   31     31   
);
   32     32   
static RETENTIONCONFIGURATION_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static(
   34     34   
        "com.amazonaws.configservice#RetentionConfiguration$Name",
   35     35   
        "com.amazonaws.configservice",
   36     36   
        "RetentionConfiguration",
   37     37   
    ),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "name",
          39  +
    "Name",
   40     40   
    0,
   41     41   
);
   42     42   
static RETENTIONCONFIGURATION_MEMBER_RETENTION_PERIOD_IN_DAYS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.configservice#RetentionConfiguration$RetentionPeriodInDays",
   45     45   
        "com.amazonaws.configservice",
   46     46   
        "RetentionConfiguration",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::Integer,
   49         -
    "retention_period_in_days",
          49  +
    "RetentionPeriodInDays",
   50     50   
    1,
   51     51   
);
   52     52   
static RETENTIONCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   53     53   
    RETENTIONCONFIGURATION_SCHEMA_ID,
   54     54   
    ::aws_smithy_schema::ShapeType::Structure,
   55     55   
    &[
   56     56   
        &RETENTIONCONFIGURATION_MEMBER_NAME,
   57     57   
        &RETENTIONCONFIGURATION_MEMBER_RETENTION_PERIOD_IN_DAYS,
   58     58   
    ],
   59     59   
);
   60     60   
impl RetentionConfiguration {
   61     61   
    /// The schema for this shape.
   62     62   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RETENTIONCONFIGURATION_SCHEMA;
   63     63   
}
   64     64   
impl ::aws_smithy_schema::serde::SerializableStruct for RetentionConfiguration {
   65     65   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   66     66   
    fn serialize_members(
   67     67   
        &self,
   68     68   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   69     69   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   70     70   
        {
   71     71   
            let val = &self.name;
   72     72   
            ser.write_string(&RETENTIONCONFIGURATION_MEMBER_NAME, val)?;
   73     73   
        }
   74     74   
        {
   75     75   
            let val = &self.retention_period_in_days;
   76     76   
            ser.write_integer(&RETENTIONCONFIGURATION_MEMBER_RETENTION_PERIOD_IN_DAYS, *val)?;
   77     77   
        }
   78     78   
        Ok(())
   79     79   
    }
   80     80   
}
   81     81   
impl RetentionConfiguration {
   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(&RETENTIONCONFIGURATION_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&RETENTIONCONFIGURATION_SCHEMA, &mut |member, deser| {
   96     96   
            match member.member_index() {
   97     97   
                Some(0) => {
   98     98   
                    builder.name = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                Some(1) => {
  101    101   
                    builder.retention_period_in_days = Some(deser.read_integer(member)?);
  102    102   
                }
  103    103   
                _ => {}
  104    104   
            }
  105    105   
            Ok(())
  106    106   
        })?;
         107  +
        builder.name = builder.name.or(Some(String::new()));
         108  +
        builder.retention_period_in_days = builder.retention_period_in_days.or(Some(0i32));
  107    109   
        builder
  108    110   
            .build()
  109    111   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  110    112   
    }
  111    113   
}
         114  +
impl RetentionConfiguration {
         115  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         116  +
    pub fn deserialize_with_response(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         118  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         119  +
        _status: u16,
         120  +
        _body: &[u8],
         121  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         122  +
        Self::deserialize(deserializer)
         123  +
    }
         124  +
}
  112    125   
impl RetentionConfiguration {
  113    126   
    /// Creates a new builder-style object to manufacture [`RetentionConfiguration`](crate::types::RetentionConfiguration).
  114    127   
    pub fn builder() -> crate::types::builders::RetentionConfigurationBuilder {
  115    128   
        crate::types::builders::RetentionConfigurationBuilder::default()
  116    129   
    }
  117    130   
}
  118    131   
  119    132   
/// A builder for [`RetentionConfiguration`](crate::types::RetentionConfiguration).
  120    133   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  121    134   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_scope.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_source.rs

@@ -21,21 +204,212 @@
   41     41   
    /// <p>Provides the runtime system, policy definition, and whether debug logging is enabled. Required when owner is set to <code>CUSTOM_POLICY</code>.</p>
   42     42   
    pub fn custom_policy_details(&self) -> ::std::option::Option<&crate::types::CustomPolicyDetails> {
   43     43   
        self.custom_policy_details.as_ref()
   44     44   
    }
   45     45   
}
   46     46   
static SOURCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Source", "com.amazonaws.configservice", "Source");
   48     48   
static SOURCE_MEMBER_OWNER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Source$Owner", "com.amazonaws.configservice", "Source"),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "owner",
          51  +
    "Owner",
   52     52   
    0,
   53     53   
);
   54     54   
static SOURCE_MEMBER_SOURCE_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.configservice#Source$SourceIdentifier",
   57     57   
        "com.amazonaws.configservice",
   58     58   
        "Source",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "source_identifier",
          61  +
    "SourceIdentifier",
   62     62   
    1,
   63     63   
);
   64     64   
static SOURCE_MEMBER_SOURCE_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.configservice#Source$SourceDetails",
   67     67   
        "com.amazonaws.configservice",
   68     68   
        "Source",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::List,
   71         -
    "source_details",
          71  +
    "SourceDetails",
   72     72   
    2,
   73     73   
);
   74     74   
static SOURCE_MEMBER_CUSTOM_POLICY_DETAILS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.configservice#Source$CustomPolicyDetails",
   77     77   
        "com.amazonaws.configservice",
   78     78   
        "Source",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::Structure,
   81         -
    "custom_policy_details",
          81  +
    "CustomPolicyDetails",
   82     82   
    3,
   83     83   
);
   84     84   
static SOURCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   85     85   
    SOURCE_SCHEMA_ID,
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87     87   
    &[
   88     88   
        &SOURCE_MEMBER_OWNER,
   89     89   
        &SOURCE_MEMBER_SOURCE_IDENTIFIER,
   90     90   
        &SOURCE_MEMBER_SOURCE_DETAILS,
   91     91   
        &SOURCE_MEMBER_CUSTOM_POLICY_DETAILS,
   92     92   
    ],
   93     93   
);
   94     94   
impl Source {
   95     95   
    /// The schema for this shape.
   96     96   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &SOURCE_SCHEMA;
   97     97   
}
   98     98   
impl ::aws_smithy_schema::serde::SerializableStruct for Source {
   99     99   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  100    100   
    fn serialize_members(
  101    101   
        &self,
  102    102   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  103    103   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  104    104   
        {
  105    105   
            let val = &self.owner;
  106    106   
            ser.write_string(&SOURCE_MEMBER_OWNER, val.as_str())?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.source_identifier {
  109    109   
            ser.write_string(&SOURCE_MEMBER_SOURCE_IDENTIFIER, val)?;
  110    110   
        }
  111    111   
        if let Some(ref val) = self.source_details {
  112    112   
            ser.write_list(
  113    113   
                &SOURCE_MEMBER_SOURCE_DETAILS,
  114    114   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  115    115   
                    for item in val {
  116    116   
                        ser.write_struct(crate::types::SourceDetail::SCHEMA, item)?;
  117    117   
                    }
  118    118   
                    Ok(())
  119    119   
                },
  120    120   
            )?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.custom_policy_details {
  123    123   
            ser.write_struct(&SOURCE_MEMBER_CUSTOM_POLICY_DETAILS, val)?;
  124    124   
        }
  125    125   
        Ok(())
  126    126   
    }
  127    127   
}
  128    128   
impl Source {
  129    129   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  130         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  131         -
        deserializer: &mut D,
         130  +
    pub fn deserialize(
         131  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  132    132   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  133    133   
        #[allow(unused_variables, unused_mut)]
  134    134   
        let mut builder = Self::builder();
  135    135   
        #[allow(
  136    136   
            unused_variables,
  137    137   
            unreachable_code,
  138    138   
            clippy::single_match,
  139    139   
            clippy::match_single_binding,
  140    140   
            clippy::diverging_sub_expression
  141    141   
        )]
  142         -
        deserializer.read_struct(&SOURCE_SCHEMA, (), |_, member, deser| {
         142  +
        deserializer.read_struct(&SOURCE_SCHEMA, &mut |member, deser| {
  143    143   
            match member.member_index() {
  144    144   
                Some(0) => {
  145    145   
                    builder.owner = Some(crate::types::Owner::from(deser.read_string(member)?.as_str()));
  146    146   
                }
  147    147   
                Some(1) => {
  148    148   
                    builder.source_identifier = Some(deser.read_string(member)?);
  149    149   
                }
  150    150   
                Some(2) => {
  151    151   
                    builder.source_details = Some({
  152         -
                        let container = if let Some(cap) = deser.container_size() {
  153         -
                            Vec::with_capacity(cap)
  154         -
                        } else {
  155         -
                            Vec::new()
  156         -
                        };
  157         -
                        deser.read_list(member, container, |mut list, deser| {
  158         -
                            list.push(crate::types::SourceDetail::deserialize(deser)?);
  159         -
                            Ok(list)
  160         -
                        })?
         152  +
                        let mut container = Vec::new();
         153  +
                        deser.read_list(member, &mut |deser| {
         154  +
                            container.push(crate::types::SourceDetail::deserialize(deser)?);
         155  +
                            Ok(())
         156  +
                        })?;
         157  +
                        container
  161    158   
                    });
  162    159   
                }
  163    160   
                Some(3) => {
  164    161   
                    builder.custom_policy_details = Some(crate::types::CustomPolicyDetails::deserialize(deser)?);
  165    162   
                }
  166    163   
                _ => {}
  167    164   
            }
  168    165   
            Ok(())
  169    166   
        })?;
  170    167   
        builder
  171    168   
            .build()
  172    169   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  173    170   
    }
  174    171   
}
         172  +
impl Source {
         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  +
}
  175    183   
impl Source {
  176    184   
    /// Creates a new builder-style object to manufacture [`Source`](crate::types::Source).
  177    185   
    pub fn builder() -> crate::types::builders::SourceBuilder {
  178    186   
        crate::types::builders::SourceBuilder::default()
  179    187   
    }
  180    188   
}
  181    189   
  182    190   
/// A builder for [`Source`](crate::types::Source).
  183    191   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  184    192   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_source_detail.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_ssm_controls.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_static_value.rs

@@ -1,1 +127,129 @@
   16     16   
}
   17     17   
static STATICVALUE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   18     18   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#StaticValue", "com.amazonaws.configservice", "StaticValue");
   19     19   
static STATICVALUE_MEMBER_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   20     20   
    ::aws_smithy_schema::ShapeId::from_static(
   21     21   
        "com.amazonaws.configservice#StaticValue$Values",
   22     22   
        "com.amazonaws.configservice",
   23     23   
        "StaticValue",
   24     24   
    ),
   25     25   
    ::aws_smithy_schema::ShapeType::List,
   26         -
    "values",
          26  +
    "Values",
   27     27   
    0,
   28     28   
);
   29     29   
static STATICVALUE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   30     30   
    STATICVALUE_SCHEMA_ID,
   31     31   
    ::aws_smithy_schema::ShapeType::Structure,
   32     32   
    &[&STATICVALUE_MEMBER_VALUES],
   33     33   
);
   34     34   
impl StaticValue {
   35     35   
    /// The schema for this shape.
   36     36   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STATICVALUE_SCHEMA;
   37     37   
}
   38     38   
impl ::aws_smithy_schema::serde::SerializableStruct for StaticValue {
   39     39   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   40     40   
    fn serialize_members(
   41     41   
        &self,
   42     42   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   43     43   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   44     44   
        {
   45     45   
            let val = &self.values;
   46     46   
   47     47   
            ser.write_list(
   48     48   
                &STATICVALUE_MEMBER_VALUES,
   49     49   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   50     50   
                    for item in val {
   51     51   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
   52     52   
                    }
   53     53   
                    Ok(())
   54     54   
                },
   55     55   
            )?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl StaticValue {
   61     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        #[allow(unused_variables, unused_mut)]
   66     66   
        let mut builder = Self::builder();
   67     67   
        #[allow(
   68     68   
            unused_variables,
   69     69   
            unreachable_code,
   70     70   
            clippy::single_match,
   71     71   
            clippy::match_single_binding,
   72     72   
            clippy::diverging_sub_expression
   73     73   
        )]
   74         -
        deserializer.read_struct(&STATICVALUE_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&STATICVALUE_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77         -
                    builder.values = Some({
   78         -
                        let container = if let Some(cap) = deser.container_size() {
   79         -
                            Vec::with_capacity(cap)
   80         -
                        } else {
   81         -
                            Vec::new()
   82         -
                        };
   83         -
                        deser.read_list(member, container, |mut list, deser| {
   84         -
                            list.push(deser.read_string(member)?);
   85         -
                            Ok(list)
   86         -
                        })?
   87         -
                    });
          77  +
                    builder.values = Some(deser.read_string_list(member)?);
   88     78   
                }
   89     79   
                _ => {}
   90     80   
            }
   91     81   
            Ok(())
   92     82   
        })?;
          83  +
        builder.values = builder.values.or(Some(Vec::new()));
   93     84   
        builder
   94     85   
            .build()
   95     86   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   96     87   
    }
   97     88   
}
          89  +
impl StaticValue {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   98    100   
impl StaticValue {
   99    101   
    /// Creates a new builder-style object to manufacture [`StaticValue`](crate::types::StaticValue).
  100    102   
    pub fn builder() -> crate::types::builders::StaticValueBuilder {
  101    103   
        crate::types::builders::StaticValueBuilder::default()
  102    104   
    }
  103    105   
}
  104    106   
  105    107   
/// A builder for [`StaticValue`](crate::types::StaticValue).
  106    108   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  107    109   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_status_detail_filters.rs

@@ -46,46 +174,185 @@
   66     66   
    "com.amazonaws.configservice",
   67     67   
    "StatusDetailFilters",
   68     68   
);
   69     69   
static STATUSDETAILFILTERS_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.configservice#StatusDetailFilters$AccountId",
   72     72   
        "com.amazonaws.configservice",
   73     73   
        "StatusDetailFilters",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "account_id",
          76  +
    "AccountId",
   77     77   
    0,
   78     78   
);
   79     79   
static STATUSDETAILFILTERS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.configservice#StatusDetailFilters$MemberAccountRuleStatus",
   82     82   
        "com.amazonaws.configservice",
   83     83   
        "StatusDetailFilters",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "member_account_rule_status",
          86  +
    "MemberAccountRuleStatus",
   87     87   
    1,
   88     88   
);
   89     89   
static STATUSDETAILFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   90     90   
    STATUSDETAILFILTERS_SCHEMA_ID,
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92     92   
    &[
   93     93   
        &STATUSDETAILFILTERS_MEMBER_ACCOUNT_ID,
   94     94   
        &STATUSDETAILFILTERS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS,
   95     95   
    ],
   96     96   
);
   97     97   
impl StatusDetailFilters {
   98     98   
    /// The schema for this shape.
   99     99   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STATUSDETAILFILTERS_SCHEMA;
  100    100   
}
  101    101   
impl ::aws_smithy_schema::serde::SerializableStruct for StatusDetailFilters {
  102    102   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  103    103   
    fn serialize_members(
  104    104   
        &self,
  105    105   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  106    106   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  107    107   
        if let Some(ref val) = self.account_id {
  108    108   
            ser.write_string(&STATUSDETAILFILTERS_MEMBER_ACCOUNT_ID, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.member_account_rule_status {
  111    111   
            ser.write_string(&STATUSDETAILFILTERS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS, val.as_str())?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl StatusDetailFilters {
  117    117   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  118         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  119         -
        deserializer: &mut D,
         118  +
    pub fn deserialize(
         119  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  120    120   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  121    121   
        #[allow(unused_variables, unused_mut)]
  122    122   
        let mut builder = Self::builder();
  123    123   
        #[allow(
  124    124   
            unused_variables,
  125    125   
            unreachable_code,
  126    126   
            clippy::single_match,
  127    127   
            clippy::match_single_binding,
  128    128   
            clippy::diverging_sub_expression
  129    129   
        )]
  130         -
        deserializer.read_struct(&STATUSDETAILFILTERS_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&STATUSDETAILFILTERS_SCHEMA, &mut |member, deser| {
  131    131   
            match member.member_index() {
  132    132   
                Some(0) => {
  133    133   
                    builder.account_id = Some(deser.read_string(member)?);
  134    134   
                }
  135    135   
                Some(1) => {
  136    136   
                    builder.member_account_rule_status = Some(crate::types::MemberAccountRuleStatus::from(deser.read_string(member)?.as_str()));
  137    137   
                }
  138    138   
                _ => {}
  139    139   
            }
  140    140   
            Ok(())
  141    141   
        })?;
  142    142   
        Ok(builder.build())
  143    143   
    }
  144    144   
}
         145  +
impl StatusDetailFilters {
         146  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         147  +
    pub fn deserialize_with_response(
         148  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         149  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         150  +
        _status: u16,
         151  +
        _body: &[u8],
         152  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         153  +
        Self::deserialize(deserializer)
         154  +
    }
         155  +
}
  145    156   
impl StatusDetailFilters {
  146    157   
    /// Creates a new builder-style object to manufacture [`StatusDetailFilters`](crate::types::StatusDetailFilters).
  147    158   
    pub fn builder() -> crate::types::builders::StatusDetailFiltersBuilder {
  148    159   
        crate::types::builders::StatusDetailFiltersBuilder::default()
  149    160   
    }
  150    161   
}
  151    162   
  152    163   
/// A builder for [`StatusDetailFilters`](crate::types::StatusDetailFilters).
  153    164   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  154    165   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_stored_query.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_stored_query_metadata.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_tag.rs

@@ -1,1 +118,129 @@
   17     17   
    /// <p>The optional part of a key-value pair that make up a tag. A value acts as a descriptor within a tag category (key).</p>
   18     18   
    pub fn value(&self) -> ::std::option::Option<&str> {
   19     19   
        self.value.as_deref()
   20     20   
    }
   21     21   
}
   22     22   
static TAG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Tag", "com.amazonaws.configservice", "Tag");
   24     24   
static TAG_MEMBER_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Tag$Key", "com.amazonaws.configservice", "Tag"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "key",
          27  +
    "Key",
   28     28   
    0,
   29     29   
);
   30     30   
static TAG_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#Tag$Value", "com.amazonaws.configservice", "Tag"),
   32     32   
    ::aws_smithy_schema::ShapeType::String,
   33         -
    "value",
          33  +
    "Value",
   34     34   
    1,
   35     35   
);
   36     36   
static TAG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     37   
    TAG_SCHEMA_ID,
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39     39   
    &[&TAG_MEMBER_KEY, &TAG_MEMBER_VALUE],
   40     40   
);
   41     41   
impl Tag {
   42     42   
    /// The schema for this shape.
   43     43   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TAG_SCHEMA;
   44     44   
}
   45     45   
impl ::aws_smithy_schema::serde::SerializableStruct for Tag {
   46     46   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   47     47   
    fn serialize_members(
   48     48   
        &self,
   49     49   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   50     50   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        if let Some(ref val) = self.key {
   52     52   
            ser.write_string(&TAG_MEMBER_KEY, val)?;
   53     53   
        }
   54     54   
        if let Some(ref val) = self.value {
   55     55   
            ser.write_string(&TAG_MEMBER_VALUE, val)?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl Tag {
   61     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        #[allow(unused_variables, unused_mut)]
   66     66   
        let mut builder = Self::builder();
   67     67   
        #[allow(
   68     68   
            unused_variables,
   69     69   
            unreachable_code,
   70     70   
            clippy::single_match,
   71     71   
            clippy::match_single_binding,
   72     72   
            clippy::diverging_sub_expression
   73     73   
        )]
   74         -
        deserializer.read_struct(&TAG_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&TAG_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77     77   
                    builder.key = Some(deser.read_string(member)?);
   78     78   
                }
   79     79   
                Some(1) => {
   80     80   
                    builder.value = Some(deser.read_string(member)?);
   81     81   
                }
   82     82   
                _ => {}
   83     83   
            }
   84     84   
            Ok(())
   85     85   
        })?;
   86     86   
        Ok(builder.build())
   87     87   
    }
   88     88   
}
          89  +
impl Tag {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   89    100   
impl Tag {
   90    101   
    /// Creates a new builder-style object to manufacture [`Tag`](crate::types::Tag).
   91    102   
    pub fn builder() -> crate::types::builders::TagBuilder {
   92    103   
        crate::types::builders::TagBuilder::default()
   93    104   
    }
   94    105   
}
   95    106   
   96    107   
/// A builder for [`Tag`](crate::types::Tag).
   97    108   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   98    109   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_template_ssm_document_details.rs

@@ -10,10 +141,153 @@
   30     30   
    "com.amazonaws.configservice",
   31     31   
    "TemplateSSMDocumentDetails",
   32     32   
);
   33     33   
static TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   34     34   
    ::aws_smithy_schema::ShapeId::from_static(
   35     35   
        "com.amazonaws.configservice#TemplateSSMDocumentDetails$DocumentName",
   36     36   
        "com.amazonaws.configservice",
   37     37   
        "TemplateSSMDocumentDetails",
   38     38   
    ),
   39     39   
    ::aws_smithy_schema::ShapeType::String,
   40         -
    "document_name",
          40  +
    "DocumentName",
   41     41   
    0,
   42     42   
);
   43     43   
static TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.configservice#TemplateSSMDocumentDetails$DocumentVersion",
   46     46   
        "com.amazonaws.configservice",
   47     47   
        "TemplateSSMDocumentDetails",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "document_version",
          50  +
    "DocumentVersion",
   51     51   
    1,
   52     52   
);
   53     53   
static TEMPLATESSMDOCUMENTDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   54     54   
    TEMPLATESSMDOCUMENTDETAILS_SCHEMA_ID,
   55     55   
    ::aws_smithy_schema::ShapeType::Structure,
   56     56   
    &[
   57     57   
        &TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_NAME,
   58     58   
        &TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_VERSION,
   59     59   
    ],
   60     60   
);
   61     61   
impl TemplateSsmDocumentDetails {
   62     62   
    /// The schema for this shape.
   63     63   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TEMPLATESSMDOCUMENTDETAILS_SCHEMA;
   64     64   
}
   65     65   
impl ::aws_smithy_schema::serde::SerializableStruct for TemplateSsmDocumentDetails {
   66     66   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   67     67   
    fn serialize_members(
   68     68   
        &self,
   69     69   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   70     70   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   71     71   
        {
   72     72   
            let val = &self.document_name;
   73     73   
            ser.write_string(&TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_NAME, val)?;
   74     74   
        }
   75     75   
        if let Some(ref val) = self.document_version {
   76     76   
            ser.write_string(&TEMPLATESSMDOCUMENTDETAILS_MEMBER_DOCUMENT_VERSION, val)?;
   77     77   
        }
   78     78   
        Ok(())
   79     79   
    }
   80     80   
}
   81     81   
impl TemplateSsmDocumentDetails {
   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(&TEMPLATESSMDOCUMENTDETAILS_SCHEMA, (), |_, member, deser| {
          95  +
        deserializer.read_struct(&TEMPLATESSMDOCUMENTDETAILS_SCHEMA, &mut |member, deser| {
   96     96   
            match member.member_index() {
   97     97   
                Some(0) => {
   98     98   
                    builder.document_name = Some(deser.read_string(member)?);
   99     99   
                }
  100    100   
                Some(1) => {
  101    101   
                    builder.document_version = Some(deser.read_string(member)?);
  102    102   
                }
  103    103   
                _ => {}
  104    104   
            }
  105    105   
            Ok(())
  106    106   
        })?;
         107  +
        builder.document_name = builder.document_name.or(Some(String::new()));
  107    108   
        builder
  108    109   
            .build()
  109    110   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  110    111   
    }
  111    112   
}
         113  +
impl TemplateSsmDocumentDetails {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
  112    124   
impl TemplateSsmDocumentDetails {
  113    125   
    /// Creates a new builder-style object to manufacture [`TemplateSsmDocumentDetails`](crate::types::TemplateSsmDocumentDetails).
  114    126   
    pub fn builder() -> crate::types::builders::TemplateSsmDocumentDetailsBuilder {
  115    127   
        crate::types::builders::TemplateSsmDocumentDetailsBuilder::default()
  116    128   
    }
  117    129   
}
  118    130   
  119    131   
/// A builder for [`TemplateSsmDocumentDetails`](crate::types::TemplateSsmDocumentDetails).
  120    132   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  121    133   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/config/src/types/_time_window.rs

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static TIMEWINDOW_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.configservice#TimeWindow", "com.amazonaws.configservice", "TimeWindow");
   24     24   
static TIMEWINDOW_MEMBER_START_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.configservice#TimeWindow$StartTime",
   27     27   
        "com.amazonaws.configservice",
   28     28   
        "TimeWindow",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::Timestamp,
   31         -
    "start_time",
          31  +
    "StartTime",
   32     32   
    0,
   33     33   
);
   34     34   
static TIMEWINDOW_MEMBER_END_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.configservice#TimeWindow$EndTime",
   37     37   
        "com.amazonaws.configservice",
   38     38   
        "TimeWindow",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::Timestamp,
   41         -
    "end_time",
          41  +
    "EndTime",
   42     42   
    1,
   43     43   
);
   44     44   
static TIMEWINDOW_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    TIMEWINDOW_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&TIMEWINDOW_MEMBER_START_TIME, &TIMEWINDOW_MEMBER_END_TIME],
   48     48   
);
   49     49   
impl TimeWindow {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TIMEWINDOW_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for TimeWindow {
   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.start_time {
   60     60   
            ser.write_timestamp(&TIMEWINDOW_MEMBER_START_TIME, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.end_time {
   63     63   
            ser.write_timestamp(&TIMEWINDOW_MEMBER_END_TIME, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl TimeWindow {
   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(&TIMEWINDOW_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&TIMEWINDOW_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.start_time = Some(deser.read_timestamp(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.end_time = Some(deser.read_timestamp(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl TimeWindow {
          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 TimeWindow {
   98    109   
    /// Creates a new builder-style object to manufacture [`TimeWindow`](crate::types::TimeWindow).
   99    110   
    pub fn builder() -> crate::types::builders::TimeWindowBuilder {
  100    111   
        crate::types::builders::TimeWindowBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`TimeWindow`](crate::types::TimeWindow).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]