AWS SDK

AWS SDK

rev. 32b1b3c3761061baed26023be3219639e42d7d12

Files changed:

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

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

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

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

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

@@ -72,72 +273,286 @@
   92     92   
    "com.amazonaws.configservice",
   93     93   
    "MemberAccountStatus",
   94     94   
);
   95     95   
static MEMBERACCOUNTSTATUS_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.configservice#MemberAccountStatus$AccountId",
   98     98   
        "com.amazonaws.configservice",
   99     99   
        "MemberAccountStatus",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "account_id",
         102  +
    "AccountId",
  103    103   
    0,
  104    104   
);
  105    105   
static MEMBERACCOUNTSTATUS_MEMBER_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.configservice#MemberAccountStatus$ConfigRuleName",
  108    108   
        "com.amazonaws.configservice",
  109    109   
        "MemberAccountStatus",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "config_rule_name",
         112  +
    "ConfigRuleName",
  113    113   
    1,
  114    114   
);
  115    115   
static MEMBERACCOUNTSTATUS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.configservice#MemberAccountStatus$MemberAccountRuleStatus",
  118    118   
        "com.amazonaws.configservice",
  119    119   
        "MemberAccountStatus",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "member_account_rule_status",
         122  +
    "MemberAccountRuleStatus",
  123    123   
    2,
  124    124   
);
  125    125   
static MEMBERACCOUNTSTATUS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.configservice#MemberAccountStatus$ErrorCode",
  128    128   
        "com.amazonaws.configservice",
  129    129   
        "MemberAccountStatus",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "error_code",
         132  +
    "ErrorCode",
  133    133   
    3,
  134    134   
);
  135    135   
static MEMBERACCOUNTSTATUS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.configservice#MemberAccountStatus$ErrorMessage",
  138    138   
        "com.amazonaws.configservice",
  139    139   
        "MemberAccountStatus",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "error_message",
         142  +
    "ErrorMessage",
  143    143   
    4,
  144    144   
);
  145    145   
static MEMBERACCOUNTSTATUS_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.configservice#MemberAccountStatus$LastUpdateTime",
  148    148   
        "com.amazonaws.configservice",
  149    149   
        "MemberAccountStatus",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Timestamp,
  152         -
    "last_update_time",
         152  +
    "LastUpdateTime",
  153    153   
    5,
  154    154   
);
  155    155   
static MEMBERACCOUNTSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    MEMBERACCOUNTSTATUS_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &MEMBERACCOUNTSTATUS_MEMBER_ACCOUNT_ID,
  160    160   
        &MEMBERACCOUNTSTATUS_MEMBER_CONFIG_RULE_NAME,
  161    161   
        &MEMBERACCOUNTSTATUS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS,
  162    162   
        &MEMBERACCOUNTSTATUS_MEMBER_ERROR_CODE,
  163    163   
        &MEMBERACCOUNTSTATUS_MEMBER_ERROR_MESSAGE,
  164    164   
        &MEMBERACCOUNTSTATUS_MEMBER_LAST_UPDATE_TIME,
  165    165   
    ],
  166    166   
);
  167    167   
impl MemberAccountStatus {
  168    168   
    /// The schema for this shape.
  169    169   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MEMBERACCOUNTSTATUS_SCHEMA;
  170    170   
}
  171    171   
impl ::aws_smithy_schema::serde::SerializableStruct for MemberAccountStatus {
  172    172   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  173    173   
    fn serialize_members(
  174    174   
        &self,
  175    175   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  176    176   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        {
  178    178   
            let val = &self.account_id;
  179    179   
            ser.write_string(&MEMBERACCOUNTSTATUS_MEMBER_ACCOUNT_ID, val)?;
  180    180   
        }
  181    181   
        {
  182    182   
            let val = &self.config_rule_name;
  183    183   
            ser.write_string(&MEMBERACCOUNTSTATUS_MEMBER_CONFIG_RULE_NAME, val)?;
  184    184   
        }
  185    185   
        {
  186    186   
            let val = &self.member_account_rule_status;
  187    187   
            ser.write_string(&MEMBERACCOUNTSTATUS_MEMBER_MEMBER_ACCOUNT_RULE_STATUS, val.as_str())?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.error_code {
  190    190   
            ser.write_string(&MEMBERACCOUNTSTATUS_MEMBER_ERROR_CODE, val)?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.error_message {
  193    193   
            ser.write_string(&MEMBERACCOUNTSTATUS_MEMBER_ERROR_MESSAGE, val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.last_update_time {
  196    196   
            ser.write_timestamp(&MEMBERACCOUNTSTATUS_MEMBER_LAST_UPDATE_TIME, val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl MemberAccountStatus {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&MEMBERACCOUNTSTATUS_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&MEMBERACCOUNTSTATUS_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.account_id = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.config_rule_name = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.member_account_rule_status = Some(crate::types::MemberAccountRuleStatus::from(deser.read_string(member)?.as_str()));
  225    225   
                }
  226    226   
                Some(3) => {
  227    227   
                    builder.error_code = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(4) => {
  230    230   
                    builder.error_message = Some(deser.read_string(member)?);
  231    231   
                }
  232    232   
                Some(5) => {
  233    233   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  234    234   
                }
  235    235   
                _ => {}
  236    236   
            }
  237    237   
            Ok(())
  238    238   
        })?;
         239  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         240  +
        builder.config_rule_name = builder.config_rule_name.or(Some(String::new()));
  239    241   
        builder
  240    242   
            .build()
  241    243   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  242    244   
    }
  243    245   
}
         246  +
impl MemberAccountStatus {
         247  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         248  +
    pub fn deserialize_with_response(
         249  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         250  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         251  +
        _status: u16,
         252  +
        _body: &[u8],
         253  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         254  +
        Self::deserialize(deserializer)
         255  +
    }
         256  +
}
  244    257   
impl MemberAccountStatus {
  245    258   
    /// Creates a new builder-style object to manufacture [`MemberAccountStatus`](crate::types::MemberAccountStatus).
  246    259   
    pub fn builder() -> crate::types::builders::MemberAccountStatusBuilder {
  247    260   
        crate::types::builders::MemberAccountStatusBuilder::default()
  248    261   
    }
  249    262   
}
  250    263   
  251    264   
/// A builder for [`MemberAccountStatus`](crate::types::MemberAccountStatus).
  252    265   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  253    266   
#[non_exhaustive]

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

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

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

@@ -38,38 +158,158 @@
   58     58   
    "com.amazonaws.configservice",
   59     59   
    "OrganizationConfigRule",
   60     60   
);
   61     61   
static ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.configservice#OrganizationConfigRule$OrganizationConfigRuleName",
   64     64   
        "com.amazonaws.configservice",
   65     65   
        "OrganizationConfigRule",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "organization_config_rule_name",
          68  +
    "OrganizationConfigRuleName",
   69     69   
    0,
   70     70   
);
   71     71   
static ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CONFIG_RULE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.configservice#OrganizationConfigRule$OrganizationConfigRuleArn",
   74     74   
        "com.amazonaws.configservice",
   75     75   
        "OrganizationConfigRule",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "organization_config_rule_arn",
          78  +
    "OrganizationConfigRuleArn",
   79     79   
    1,
   80     80   
);
   81     81   
static ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_MANAGED_RULE_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.configservice#OrganizationConfigRule$OrganizationManagedRuleMetadata",
   84     84   
        "com.amazonaws.configservice",
   85     85   
        "OrganizationConfigRule",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88         -
    "organization_managed_rule_metadata",
          88  +
    "OrganizationManagedRuleMetadata",
   89     89   
    2,
   90     90   
);
   91     91   
static ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CUSTOM_RULE_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.configservice#OrganizationConfigRule$OrganizationCustomRuleMetadata",
   94     94   
        "com.amazonaws.configservice",
   95     95   
        "OrganizationConfigRule",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Structure,
   98         -
    "organization_custom_rule_metadata",
          98  +
    "OrganizationCustomRuleMetadata",
   99     99   
    3,
  100    100   
);
  101    101   
static ORGANIZATIONCONFIGRULE_MEMBER_EXCLUDED_ACCOUNTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.configservice#OrganizationConfigRule$ExcludedAccounts",
  104    104   
        "com.amazonaws.configservice",
  105    105   
        "OrganizationConfigRule",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::List,
  108         -
    "excluded_accounts",
         108  +
    "ExcludedAccounts",
  109    109   
    4,
  110    110   
);
  111    111   
static ORGANIZATIONCONFIGRULE_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.configservice#OrganizationConfigRule$LastUpdateTime",
  114    114   
        "com.amazonaws.configservice",
  115    115   
        "OrganizationConfigRule",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::Timestamp,
  118         -
    "last_update_time",
         118  +
    "LastUpdateTime",
  119    119   
    5,
  120    120   
);
  121    121   
static ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CUSTOM_POLICY_RULE_METADATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.configservice#OrganizationConfigRule$OrganizationCustomPolicyRuleMetadata",
  124    124   
        "com.amazonaws.configservice",
  125    125   
        "OrganizationConfigRule",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::Structure,
  128         -
    "organization_custom_policy_rule_metadata",
         128  +
    "OrganizationCustomPolicyRuleMetadata",
  129    129   
    6,
  130    130   
);
  131    131   
static ORGANIZATIONCONFIGRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  132    132   
    ORGANIZATIONCONFIGRULE_SCHEMA_ID,
  133    133   
    ::aws_smithy_schema::ShapeType::Structure,
  134    134   
    &[
  135    135   
        &ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CONFIG_RULE_NAME,
  136    136   
        &ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CONFIG_RULE_ARN,
  137    137   
        &ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_MANAGED_RULE_METADATA,
  138    138   
        &ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CUSTOM_RULE_METADATA,
@@ -160,160 +274,277 @@
  180    180   
            ser.write_timestamp(&ORGANIZATIONCONFIGRULE_MEMBER_LAST_UPDATE_TIME, val)?;
  181    181   
        }
  182    182   
        if let Some(ref val) = self.organization_custom_policy_rule_metadata {
  183    183   
            ser.write_struct(&ORGANIZATIONCONFIGRULE_MEMBER_ORGANIZATION_CUSTOM_POLICY_RULE_METADATA, val)?;
  184    184   
        }
  185    185   
        Ok(())
  186    186   
    }
  187    187   
}
  188    188   
impl OrganizationConfigRule {
  189    189   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  190         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  191         -
        deserializer: &mut D,
         190  +
    pub fn deserialize(
         191  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  192    192   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  193    193   
        #[allow(unused_variables, unused_mut)]
  194    194   
        let mut builder = Self::builder();
  195    195   
        #[allow(
  196    196   
            unused_variables,
  197    197   
            unreachable_code,
  198    198   
            clippy::single_match,
  199    199   
            clippy::match_single_binding,
  200    200   
            clippy::diverging_sub_expression
  201    201   
        )]
  202         -
        deserializer.read_struct(&ORGANIZATIONCONFIGRULE_SCHEMA, (), |_, member, deser| {
         202  +
        deserializer.read_struct(&ORGANIZATIONCONFIGRULE_SCHEMA, &mut |member, deser| {
  203    203   
            match member.member_index() {
  204    204   
                Some(0) => {
  205    205   
                    builder.organization_config_rule_name = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(1) => {
  208    208   
                    builder.organization_config_rule_arn = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(2) => {
  211    211   
                    builder.organization_managed_rule_metadata = Some(crate::types::OrganizationManagedRuleMetadata::deserialize(deser)?);
  212    212   
                }
  213    213   
                Some(3) => {
  214    214   
                    builder.organization_custom_rule_metadata = Some(crate::types::OrganizationCustomRuleMetadata::deserialize(deser)?);
  215    215   
                }
  216    216   
                Some(4) => {
  217         -
                    builder.excluded_accounts = Some({
  218         -
                        let container = if let Some(cap) = deser.container_size() {
  219         -
                            Vec::with_capacity(cap)
  220         -
                        } else {
  221         -
                            Vec::new()
  222         -
                        };
  223         -
                        deser.read_list(member, container, |mut list, deser| {
  224         -
                            list.push(deser.read_string(member)?);
  225         -
                            Ok(list)
  226         -
                        })?
  227         -
                    });
         217  +
                    builder.excluded_accounts = Some(deser.read_string_list(member)?);
  228    218   
                }
  229    219   
                Some(5) => {
  230    220   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  231    221   
                }
  232    222   
                Some(6) => {
  233    223   
                    builder.organization_custom_policy_rule_metadata =
  234    224   
                        Some(crate::types::OrganizationCustomPolicyRuleMetadataNoPolicy::deserialize(deser)?);
  235    225   
                }
  236    226   
                _ => {}
  237    227   
            }
  238    228   
            Ok(())
  239    229   
        })?;
         230  +
        builder.organization_config_rule_name = builder.organization_config_rule_name.or(Some(String::new()));
         231  +
        builder.organization_config_rule_arn = builder.organization_config_rule_arn.or(Some(String::new()));
  240    232   
        builder
  241    233   
            .build()
  242    234   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  243    235   
    }
  244    236   
}
         237  +
impl OrganizationConfigRule {
         238  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         239  +
    pub fn deserialize_with_response(
         240  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         241  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         242  +
        _status: u16,
         243  +
        _body: &[u8],
         244  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         245  +
        Self::deserialize(deserializer)
         246  +
    }
         247  +
}
  245    248   
impl OrganizationConfigRule {
  246    249   
    /// Creates a new builder-style object to manufacture [`OrganizationConfigRule`](crate::types::OrganizationConfigRule).
  247    250   
    pub fn builder() -> crate::types::builders::OrganizationConfigRuleBuilder {
  248    251   
        crate::types::builders::OrganizationConfigRuleBuilder::default()
  249    252   
    }
  250    253   
}
  251    254   
  252    255   
/// A builder for [`OrganizationConfigRule`](crate::types::OrganizationConfigRule).
  253    256   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  254    257   
#[non_exhaustive]

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

@@ -65,65 +248,260 @@
   85     85   
    "com.amazonaws.configservice",
   86     86   
    "OrganizationConfigRuleStatus",
   87     87   
);
   88     88   
static ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.configservice#OrganizationConfigRuleStatus$OrganizationConfigRuleName",
   91     91   
        "com.amazonaws.configservice",
   92     92   
        "OrganizationConfigRuleStatus",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "organization_config_rule_name",
          95  +
    "OrganizationConfigRuleName",
   96     96   
    0,
   97     97   
);
   98     98   
static ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_RULE_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.configservice#OrganizationConfigRuleStatus$OrganizationRuleStatus",
  101    101   
        "com.amazonaws.configservice",
  102    102   
        "OrganizationConfigRuleStatus",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "organization_rule_status",
         105  +
    "OrganizationRuleStatus",
  106    106   
    1,
  107    107   
);
  108    108   
static ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.configservice#OrganizationConfigRuleStatus$ErrorCode",
  111    111   
        "com.amazonaws.configservice",
  112    112   
        "OrganizationConfigRuleStatus",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "error_code",
         115  +
    "ErrorCode",
  116    116   
    2,
  117    117   
);
  118    118   
static ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.configservice#OrganizationConfigRuleStatus$ErrorMessage",
  121    121   
        "com.amazonaws.configservice",
  122    122   
        "OrganizationConfigRuleStatus",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "error_message",
         125  +
    "ErrorMessage",
  126    126   
    3,
  127    127   
);
  128    128   
static ORGANIZATIONCONFIGRULESTATUS_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.configservice#OrganizationConfigRuleStatus$LastUpdateTime",
  131    131   
        "com.amazonaws.configservice",
  132    132   
        "OrganizationConfigRuleStatus",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::Timestamp,
  135         -
    "last_update_time",
         135  +
    "LastUpdateTime",
  136    136   
    4,
  137    137   
);
  138    138   
static ORGANIZATIONCONFIGRULESTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  139    139   
    ORGANIZATIONCONFIGRULESTATUS_SCHEMA_ID,
  140    140   
    ::aws_smithy_schema::ShapeType::Structure,
  141    141   
    &[
  142    142   
        &ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_CONFIG_RULE_NAME,
  143    143   
        &ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_RULE_STATUS,
  144    144   
        &ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_CODE,
  145    145   
        &ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_MESSAGE,
  146    146   
        &ORGANIZATIONCONFIGRULESTATUS_MEMBER_LAST_UPDATE_TIME,
  147    147   
    ],
  148    148   
);
  149    149   
impl OrganizationConfigRuleStatus {
  150    150   
    /// The schema for this shape.
  151    151   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ORGANIZATIONCONFIGRULESTATUS_SCHEMA;
  152    152   
}
  153    153   
impl ::aws_smithy_schema::serde::SerializableStruct for OrganizationConfigRuleStatus {
  154    154   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  155    155   
    fn serialize_members(
  156    156   
        &self,
  157    157   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  158    158   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  159    159   
        {
  160    160   
            let val = &self.organization_config_rule_name;
  161    161   
            ser.write_string(&ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_CONFIG_RULE_NAME, val)?;
  162    162   
        }
  163    163   
        {
  164    164   
            let val = &self.organization_rule_status;
  165    165   
            ser.write_string(&ORGANIZATIONCONFIGRULESTATUS_MEMBER_ORGANIZATION_RULE_STATUS, val.as_str())?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.error_code {
  168    168   
            ser.write_string(&ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_CODE, val)?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.error_message {
  171    171   
            ser.write_string(&ORGANIZATIONCONFIGRULESTATUS_MEMBER_ERROR_MESSAGE, val)?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.last_update_time {
  174    174   
            ser.write_timestamp(&ORGANIZATIONCONFIGRULESTATUS_MEMBER_LAST_UPDATE_TIME, val)?;
  175    175   
        }
  176    176   
        Ok(())
  177    177   
    }
  178    178   
}
  179    179   
impl OrganizationConfigRuleStatus {
  180    180   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  181         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  182         -
        deserializer: &mut D,
         181  +
    pub fn deserialize(
         182  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  183    183   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  184    184   
        #[allow(unused_variables, unused_mut)]
  185    185   
        let mut builder = Self::builder();
  186    186   
        #[allow(
  187    187   
            unused_variables,
  188    188   
            unreachable_code,
  189    189   
            clippy::single_match,
  190    190   
            clippy::match_single_binding,
  191    191   
            clippy::diverging_sub_expression
  192    192   
        )]
  193         -
        deserializer.read_struct(&ORGANIZATIONCONFIGRULESTATUS_SCHEMA, (), |_, member, deser| {
         193  +
        deserializer.read_struct(&ORGANIZATIONCONFIGRULESTATUS_SCHEMA, &mut |member, deser| {
  194    194   
            match member.member_index() {
  195    195   
                Some(0) => {
  196    196   
                    builder.organization_config_rule_name = Some(deser.read_string(member)?);
  197    197   
                }
  198    198   
                Some(1) => {
  199    199   
                    builder.organization_rule_status = Some(crate::types::OrganizationRuleStatus::from(deser.read_string(member)?.as_str()));
  200    200   
                }
  201    201   
                Some(2) => {
  202    202   
                    builder.error_code = Some(deser.read_string(member)?);
  203    203   
                }
  204    204   
                Some(3) => {
  205    205   
                    builder.error_message = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(4) => {
  208    208   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  209    209   
                }
  210    210   
                _ => {}
  211    211   
            }
  212    212   
            Ok(())
  213    213   
        })?;
         214  +
        builder.organization_config_rule_name = builder.organization_config_rule_name.or(Some(String::new()));
  214    215   
        builder
  215    216   
            .build()
  216    217   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  217    218   
    }
  218    219   
}
         220  +
impl OrganizationConfigRuleStatus {
         221  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         222  +
    pub fn deserialize_with_response(
         223  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         224  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         225  +
        _status: u16,
         226  +
        _body: &[u8],
         227  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         228  +
        Self::deserialize(deserializer)
         229  +
    }
         230  +
}
  219    231   
impl OrganizationConfigRuleStatus {
  220    232   
    /// Creates a new builder-style object to manufacture [`OrganizationConfigRuleStatus`](crate::types::OrganizationConfigRuleStatus).
  221    233   
    pub fn builder() -> crate::types::builders::OrganizationConfigRuleStatusBuilder {
  222    234   
        crate::types::builders::OrganizationConfigRuleStatusBuilder::default()
  223    235   
    }
  224    236   
}
  225    237   
  226    238   
/// A builder for [`OrganizationConfigRuleStatus`](crate::types::OrganizationConfigRuleStatus).
  227    239   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  228    240   
#[non_exhaustive]

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

@@ -48,48 +168,168 @@
   68     68   
    "com.amazonaws.configservice",
   69     69   
    "OrganizationConformancePack",
   70     70   
);
   71     71   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_ORGANIZATION_CONFORMANCE_PACK_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.configservice#OrganizationConformancePack$OrganizationConformancePackName",
   74     74   
        "com.amazonaws.configservice",
   75     75   
        "OrganizationConformancePack",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "organization_conformance_pack_name",
          78  +
    "OrganizationConformancePackName",
   79     79   
    0,
   80     80   
);
   81     81   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_ORGANIZATION_CONFORMANCE_PACK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.configservice#OrganizationConformancePack$OrganizationConformancePackArn",
   84     84   
        "com.amazonaws.configservice",
   85     85   
        "OrganizationConformancePack",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "organization_conformance_pack_arn",
          88  +
    "OrganizationConformancePackArn",
   89     89   
    1,
   90     90   
);
   91     91   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_DELIVERY_S3_BUCKET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.configservice#OrganizationConformancePack$DeliveryS3Bucket",
   94     94   
        "com.amazonaws.configservice",
   95     95   
        "OrganizationConformancePack",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "delivery_s3_bucket",
          98  +
    "DeliveryS3Bucket",
   99     99   
    2,
  100    100   
);
  101    101   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_DELIVERY_S3_KEY_PREFIX: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.configservice#OrganizationConformancePack$DeliveryS3KeyPrefix",
  104    104   
        "com.amazonaws.configservice",
  105    105   
        "OrganizationConformancePack",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "delivery_s3_key_prefix",
         108  +
    "DeliveryS3KeyPrefix",
  109    109   
    3,
  110    110   
);
  111    111   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_CONFORMANCE_PACK_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.configservice#OrganizationConformancePack$ConformancePackInputParameters",
  114    114   
        "com.amazonaws.configservice",
  115    115   
        "OrganizationConformancePack",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::List,
  118         -
    "conformance_pack_input_parameters",
         118  +
    "ConformancePackInputParameters",
  119    119   
    4,
  120    120   
);
  121    121   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_EXCLUDED_ACCOUNTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.configservice#OrganizationConformancePack$ExcludedAccounts",
  124    124   
        "com.amazonaws.configservice",
  125    125   
        "OrganizationConformancePack",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::List,
  128         -
    "excluded_accounts",
         128  +
    "ExcludedAccounts",
  129    129   
    5,
  130    130   
);
  131    131   
static ORGANIZATIONCONFORMANCEPACK_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.configservice#OrganizationConformancePack$LastUpdateTime",
  134    134   
        "com.amazonaws.configservice",
  135    135   
        "OrganizationConformancePack",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::Timestamp,
  138         -
    "last_update_time",
         138  +
    "LastUpdateTime",
  139    139   
    6,
  140    140   
);
  141    141   
static ORGANIZATIONCONFORMANCEPACK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    ORGANIZATIONCONFORMANCEPACK_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &ORGANIZATIONCONFORMANCEPACK_MEMBER_ORGANIZATION_CONFORMANCE_PACK_NAME,
  146    146   
        &ORGANIZATIONCONFORMANCEPACK_MEMBER_ORGANIZATION_CONFORMANCE_PACK_ARN,
  147    147   
        &ORGANIZATIONCONFORMANCEPACK_MEMBER_DELIVERY_S3_BUCKET,
  148    148   
        &ORGANIZATIONCONFORMANCEPACK_MEMBER_DELIVERY_S3_KEY_PREFIX,
@@ -179,179 +302,303 @@
  199    199   
        }
  200    200   
        {
  201    201   
            let val = &self.last_update_time;
  202    202   
            ser.write_timestamp(&ORGANIZATIONCONFORMANCEPACK_MEMBER_LAST_UPDATE_TIME, val)?;
  203    203   
        }
  204    204   
        Ok(())
  205    205   
    }
  206    206   
}
  207    207   
impl OrganizationConformancePack {
  208    208   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  209         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  210         -
        deserializer: &mut D,
         209  +
    pub fn deserialize(
         210  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  211    211   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  212    212   
        #[allow(unused_variables, unused_mut)]
  213    213   
        let mut builder = Self::builder();
  214    214   
        #[allow(
  215    215   
            unused_variables,
  216    216   
            unreachable_code,
  217    217   
            clippy::single_match,
  218    218   
            clippy::match_single_binding,
  219    219   
            clippy::diverging_sub_expression
  220    220   
        )]
  221         -
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACK_SCHEMA, (), |_, member, deser| {
         221  +
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACK_SCHEMA, &mut |member, deser| {
  222    222   
            match member.member_index() {
  223    223   
                Some(0) => {
  224    224   
                    builder.organization_conformance_pack_name = Some(deser.read_string(member)?);
  225    225   
                }
  226    226   
                Some(1) => {
  227    227   
                    builder.organization_conformance_pack_arn = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(2) => {
  230    230   
                    builder.delivery_s3_bucket = Some(deser.read_string(member)?);
  231    231   
                }
  232    232   
                Some(3) => {
  233    233   
                    builder.delivery_s3_key_prefix = Some(deser.read_string(member)?);
  234    234   
                }
  235    235   
                Some(4) => {
  236    236   
                    builder.conformance_pack_input_parameters = Some({
  237         -
                        let container = if let Some(cap) = deser.container_size() {
  238         -
                            Vec::with_capacity(cap)
  239         -
                        } else {
  240         -
                            Vec::new()
  241         -
                        };
  242         -
                        deser.read_list(member, container, |mut list, deser| {
  243         -
                            list.push(crate::types::ConformancePackInputParameter::deserialize(deser)?);
  244         -
                            Ok(list)
  245         -
                        })?
         237  +
                        let mut container = Vec::new();
         238  +
                        deser.read_list(member, &mut |deser| {
         239  +
                            container.push(crate::types::ConformancePackInputParameter::deserialize(deser)?);
         240  +
                            Ok(())
         241  +
                        })?;
         242  +
                        container
  246    243   
                    });
  247    244   
                }
  248    245   
                Some(5) => {
  249         -
                    builder.excluded_accounts = Some({
  250         -
                        let container = if let Some(cap) = deser.container_size() {
  251         -
                            Vec::with_capacity(cap)
  252         -
                        } else {
  253         -
                            Vec::new()
  254         -
                        };
  255         -
                        deser.read_list(member, container, |mut list, deser| {
  256         -
                            list.push(deser.read_string(member)?);
  257         -
                            Ok(list)
  258         -
                        })?
  259         -
                    });
         246  +
                    builder.excluded_accounts = Some(deser.read_string_list(member)?);
  260    247   
                }
  261    248   
                Some(6) => {
  262    249   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  263    250   
                }
  264    251   
                _ => {}
  265    252   
            }
  266    253   
            Ok(())
  267    254   
        })?;
         255  +
        builder.organization_conformance_pack_name = builder.organization_conformance_pack_name.or(Some(String::new()));
         256  +
        builder.organization_conformance_pack_arn = builder.organization_conformance_pack_arn.or(Some(String::new()));
         257  +
        builder.last_update_time = builder.last_update_time.or(Some(::aws_smithy_types::DateTime::from_secs(0)));
  268    258   
        builder
  269    259   
            .build()
  270    260   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  271    261   
    }
  272    262   
}
         263  +
impl OrganizationConformancePack {
         264  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         265  +
    pub fn deserialize_with_response(
         266  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         267  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         268  +
        _status: u16,
         269  +
        _body: &[u8],
         270  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         271  +
        Self::deserialize(deserializer)
         272  +
    }
         273  +
}
  273    274   
impl OrganizationConformancePack {
  274    275   
    /// Creates a new builder-style object to manufacture [`OrganizationConformancePack`](crate::types::OrganizationConformancePack).
  275    276   
    pub fn builder() -> crate::types::builders::OrganizationConformancePackBuilder {
  276    277   
        crate::types::builders::OrganizationConformancePackBuilder::default()
  277    278   
    }
  278    279   
}
  279    280   
  280    281   
/// A builder for [`OrganizationConformancePack`](crate::types::OrganizationConformancePack).
  281    282   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  282    283   
#[non_exhaustive]

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

@@ -72,72 +275,288 @@
   92     92   
    "com.amazonaws.configservice",
   93     93   
    "OrganizationConformancePackDetailedStatus",
   94     94   
);
   95     95   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$AccountId",
   98     98   
        "com.amazonaws.configservice",
   99     99   
        "OrganizationConformancePackDetailedStatus",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::String,
  102         -
    "account_id",
         102  +
    "AccountId",
  103    103   
    0,
  104    104   
);
  105    105   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_CONFORMANCE_PACK_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$ConformancePackName",
  108    108   
        "com.amazonaws.configservice",
  109    109   
        "OrganizationConformancePackDetailedStatus",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "conformance_pack_name",
         112  +
    "ConformancePackName",
  113    113   
    1,
  114    114   
);
  115    115   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$Status",
  118    118   
        "com.amazonaws.configservice",
  119    119   
        "OrganizationConformancePackDetailedStatus",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "status",
         122  +
    "Status",
  123    123   
    2,
  124    124   
);
  125    125   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$ErrorCode",
  128    128   
        "com.amazonaws.configservice",
  129    129   
        "OrganizationConformancePackDetailedStatus",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "error_code",
         132  +
    "ErrorCode",
  133    133   
    3,
  134    134   
);
  135    135   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$ErrorMessage",
  138    138   
        "com.amazonaws.configservice",
  139    139   
        "OrganizationConformancePackDetailedStatus",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "error_message",
         142  +
    "ErrorMessage",
  143    143   
    4,
  144    144   
);
  145    145   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.configservice#OrganizationConformancePackDetailedStatus$LastUpdateTime",
  148    148   
        "com.amazonaws.configservice",
  149    149   
        "OrganizationConformancePackDetailedStatus",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Timestamp,
  152         -
    "last_update_time",
         152  +
    "LastUpdateTime",
  153    153   
    5,
  154    154   
);
  155    155   
static ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  156    156   
    ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_SCHEMA_ID,
  157    157   
    ::aws_smithy_schema::ShapeType::Structure,
  158    158   
    &[
  159    159   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ACCOUNT_ID,
  160    160   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_CONFORMANCE_PACK_NAME,
  161    161   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_STATUS,
  162    162   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_CODE,
  163    163   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_MESSAGE,
  164    164   
        &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_LAST_UPDATE_TIME,
  165    165   
    ],
  166    166   
);
  167    167   
impl OrganizationConformancePackDetailedStatus {
  168    168   
    /// The schema for this shape.
  169    169   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_SCHEMA;
  170    170   
}
  171    171   
impl ::aws_smithy_schema::serde::SerializableStruct for OrganizationConformancePackDetailedStatus {
  172    172   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  173    173   
    fn serialize_members(
  174    174   
        &self,
  175    175   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  176    176   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  177    177   
        {
  178    178   
            let val = &self.account_id;
  179    179   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ACCOUNT_ID, val)?;
  180    180   
        }
  181    181   
        {
  182    182   
            let val = &self.conformance_pack_name;
  183    183   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_CONFORMANCE_PACK_NAME, val)?;
  184    184   
        }
  185    185   
        {
  186    186   
            let val = &self.status;
  187    187   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_STATUS, val.as_str())?;
  188    188   
        }
  189    189   
        if let Some(ref val) = self.error_code {
  190    190   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_CODE, val)?;
  191    191   
        }
  192    192   
        if let Some(ref val) = self.error_message {
  193    193   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_ERROR_MESSAGE, val)?;
  194    194   
        }
  195    195   
        if let Some(ref val) = self.last_update_time {
  196    196   
            ser.write_timestamp(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_MEMBER_LAST_UPDATE_TIME, val)?;
  197    197   
        }
  198    198   
        Ok(())
  199    199   
    }
  200    200   
}
  201    201   
impl OrganizationConformancePackDetailedStatus {
  202    202   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  203         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  204         -
        deserializer: &mut D,
         203  +
    pub fn deserialize(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  205    205   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  206    206   
        #[allow(unused_variables, unused_mut)]
  207    207   
        let mut builder = Self::builder();
  208    208   
        #[allow(
  209    209   
            unused_variables,
  210    210   
            unreachable_code,
  211    211   
            clippy::single_match,
  212    212   
            clippy::match_single_binding,
  213    213   
            clippy::diverging_sub_expression
  214    214   
        )]
  215         -
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_SCHEMA, (), |_, member, deser| {
         215  +
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACKDETAILEDSTATUS_SCHEMA, &mut |member, deser| {
  216    216   
            match member.member_index() {
  217    217   
                Some(0) => {
  218    218   
                    builder.account_id = Some(deser.read_string(member)?);
  219    219   
                }
  220    220   
                Some(1) => {
  221    221   
                    builder.conformance_pack_name = Some(deser.read_string(member)?);
  222    222   
                }
  223    223   
                Some(2) => {
  224    224   
                    builder.status = Some(crate::types::OrganizationResourceDetailedStatus::from(
  225    225   
                        deser.read_string(member)?.as_str(),
  226    226   
                    ));
  227    227   
                }
  228    228   
                Some(3) => {
  229    229   
                    builder.error_code = Some(deser.read_string(member)?);
  230    230   
                }
  231    231   
                Some(4) => {
  232    232   
                    builder.error_message = Some(deser.read_string(member)?);
  233    233   
                }
  234    234   
                Some(5) => {
  235    235   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  236    236   
                }
  237    237   
                _ => {}
  238    238   
            }
  239    239   
            Ok(())
  240    240   
        })?;
         241  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         242  +
        builder.conformance_pack_name = builder.conformance_pack_name.or(Some(String::new()));
  241    243   
        builder
  242    244   
            .build()
  243    245   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  244    246   
    }
  245    247   
}
         248  +
impl OrganizationConformancePackDetailedStatus {
         249  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         250  +
    pub fn deserialize_with_response(
         251  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         252  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         253  +
        _status: u16,
         254  +
        _body: &[u8],
         255  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         256  +
        Self::deserialize(deserializer)
         257  +
    }
         258  +
}
  246    259   
impl OrganizationConformancePackDetailedStatus {
  247    260   
    /// Creates a new builder-style object to manufacture [`OrganizationConformancePackDetailedStatus`](crate::types::OrganizationConformancePackDetailedStatus).
  248    261   
    pub fn builder() -> crate::types::builders::OrganizationConformancePackDetailedStatusBuilder {
  249    262   
        crate::types::builders::OrganizationConformancePackDetailedStatusBuilder::default()
  250    263   
    }
  251    264   
}
  252    265   
  253    266   
/// A builder for [`OrganizationConformancePackDetailedStatus`](crate::types::OrganizationConformancePackDetailedStatus).
  254    267   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  255    268   
#[non_exhaustive]

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

@@ -66,66 +249,261 @@
   86     86   
    "OrganizationConformancePackStatus",
   87     87   
);
   88     88   
static ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ORGANIZATION_CONFORMANCE_PACK_NAME: ::aws_smithy_schema::Schema =
   89     89   
    ::aws_smithy_schema::Schema::new_member(
   90     90   
        ::aws_smithy_schema::ShapeId::from_static(
   91     91   
            "com.amazonaws.configservice#OrganizationConformancePackStatus$OrganizationConformancePackName",
   92     92   
            "com.amazonaws.configservice",
   93     93   
            "OrganizationConformancePackStatus",
   94     94   
        ),
   95     95   
        ::aws_smithy_schema::ShapeType::String,
   96         -
        "organization_conformance_pack_name",
          96  +
        "OrganizationConformancePackName",
   97     97   
        0,
   98     98   
    );
   99     99   
static ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.configservice#OrganizationConformancePackStatus$Status",
  102    102   
        "com.amazonaws.configservice",
  103    103   
        "OrganizationConformancePackStatus",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "status",
         106  +
    "Status",
  107    107   
    1,
  108    108   
);
  109    109   
static ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.configservice#OrganizationConformancePackStatus$ErrorCode",
  112    112   
        "com.amazonaws.configservice",
  113    113   
        "OrganizationConformancePackStatus",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "error_code",
         116  +
    "ErrorCode",
  117    117   
    2,
  118    118   
);
  119    119   
static ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.configservice#OrganizationConformancePackStatus$ErrorMessage",
  122    122   
        "com.amazonaws.configservice",
  123    123   
        "OrganizationConformancePackStatus",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::String,
  126         -
    "error_message",
         126  +
    "ErrorMessage",
  127    127   
    3,
  128    128   
);
  129    129   
static ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_LAST_UPDATE_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static(
  131    131   
        "com.amazonaws.configservice#OrganizationConformancePackStatus$LastUpdateTime",
  132    132   
        "com.amazonaws.configservice",
  133    133   
        "OrganizationConformancePackStatus",
  134    134   
    ),
  135    135   
    ::aws_smithy_schema::ShapeType::Timestamp,
  136         -
    "last_update_time",
         136  +
    "LastUpdateTime",
  137    137   
    4,
  138    138   
);
  139    139   
static ORGANIZATIONCONFORMANCEPACKSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  140    140   
    ORGANIZATIONCONFORMANCEPACKSTATUS_SCHEMA_ID,
  141    141   
    ::aws_smithy_schema::ShapeType::Structure,
  142    142   
    &[
  143    143   
        &ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ORGANIZATION_CONFORMANCE_PACK_NAME,
  144    144   
        &ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_STATUS,
  145    145   
        &ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_CODE,
  146    146   
        &ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_MESSAGE,
  147    147   
        &ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_LAST_UPDATE_TIME,
  148    148   
    ],
  149    149   
);
  150    150   
impl OrganizationConformancePackStatus {
  151    151   
    /// The schema for this shape.
  152    152   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ORGANIZATIONCONFORMANCEPACKSTATUS_SCHEMA;
  153    153   
}
  154    154   
impl ::aws_smithy_schema::serde::SerializableStruct for OrganizationConformancePackStatus {
  155    155   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  156    156   
    fn serialize_members(
  157    157   
        &self,
  158    158   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  159    159   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  160    160   
        {
  161    161   
            let val = &self.organization_conformance_pack_name;
  162    162   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ORGANIZATION_CONFORMANCE_PACK_NAME, val)?;
  163    163   
        }
  164    164   
        {
  165    165   
            let val = &self.status;
  166    166   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_STATUS, val.as_str())?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.error_code {
  169    169   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_CODE, val)?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.error_message {
  172    172   
            ser.write_string(&ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_ERROR_MESSAGE, val)?;
  173    173   
        }
  174    174   
        if let Some(ref val) = self.last_update_time {
  175    175   
            ser.write_timestamp(&ORGANIZATIONCONFORMANCEPACKSTATUS_MEMBER_LAST_UPDATE_TIME, val)?;
  176    176   
        }
  177    177   
        Ok(())
  178    178   
    }
  179    179   
}
  180    180   
impl OrganizationConformancePackStatus {
  181    181   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  182         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  183         -
        deserializer: &mut D,
         182  +
    pub fn deserialize(
         183  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  184    184   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  185    185   
        #[allow(unused_variables, unused_mut)]
  186    186   
        let mut builder = Self::builder();
  187    187   
        #[allow(
  188    188   
            unused_variables,
  189    189   
            unreachable_code,
  190    190   
            clippy::single_match,
  191    191   
            clippy::match_single_binding,
  192    192   
            clippy::diverging_sub_expression
  193    193   
        )]
  194         -
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACKSTATUS_SCHEMA, (), |_, member, deser| {
         194  +
        deserializer.read_struct(&ORGANIZATIONCONFORMANCEPACKSTATUS_SCHEMA, &mut |member, deser| {
  195    195   
            match member.member_index() {
  196    196   
                Some(0) => {
  197    197   
                    builder.organization_conformance_pack_name = Some(deser.read_string(member)?);
  198    198   
                }
  199    199   
                Some(1) => {
  200    200   
                    builder.status = Some(crate::types::OrganizationResourceStatus::from(deser.read_string(member)?.as_str()));
  201    201   
                }
  202    202   
                Some(2) => {
  203    203   
                    builder.error_code = Some(deser.read_string(member)?);
  204    204   
                }
  205    205   
                Some(3) => {
  206    206   
                    builder.error_message = Some(deser.read_string(member)?);
  207    207   
                }
  208    208   
                Some(4) => {
  209    209   
                    builder.last_update_time = Some(deser.read_timestamp(member)?);
  210    210   
                }
  211    211   
                _ => {}
  212    212   
            }
  213    213   
            Ok(())
  214    214   
        })?;
         215  +
        builder.organization_conformance_pack_name = builder.organization_conformance_pack_name.or(Some(String::new()));
  215    216   
        builder
  216    217   
            .build()
  217    218   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  218    219   
    }
  219    220   
}
         221  +
impl OrganizationConformancePackStatus {
         222  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         223  +
    pub fn deserialize_with_response(
         224  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         225  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         226  +
        _status: u16,
         227  +
        _body: &[u8],
         228  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         229  +
        Self::deserialize(deserializer)
         230  +
    }
         231  +
}
  220    232   
impl OrganizationConformancePackStatus {
  221    233   
    /// Creates a new builder-style object to manufacture [`OrganizationConformancePackStatus`](crate::types::OrganizationConformancePackStatus).
  222    234   
    pub fn builder() -> crate::types::builders::OrganizationConformancePackStatusBuilder {
  223    235   
        crate::types::builders::OrganizationConformancePackStatusBuilder::default()
  224    236   
    }
  225    237   
}
  226    238   
  227    239   
/// A builder for [`OrganizationConformancePackStatus`](crate::types::OrganizationConformancePackStatus).
  228    240   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  229    241   
#[non_exhaustive]

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

@@ -78,78 +239,239 @@
   98     98   
    "com.amazonaws.configservice",
   99     99   
    "OrganizationCustomPolicyRuleMetadata",
  100    100   
);
  101    101   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$Description",
  104    104   
        "com.amazonaws.configservice",
  105    105   
        "OrganizationCustomPolicyRuleMetadata",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "description",
         108  +
    "Description",
  109    109   
    0,
  110    110   
);
  111    111   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES: ::aws_smithy_schema::Schema =
  112    112   
    ::aws_smithy_schema::Schema::new_member(
  113    113   
        ::aws_smithy_schema::ShapeId::from_static(
  114    114   
            "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$OrganizationConfigRuleTriggerTypes",
  115    115   
            "com.amazonaws.configservice",
  116    116   
            "OrganizationCustomPolicyRuleMetadata",
  117    117   
        ),
  118    118   
        ::aws_smithy_schema::ShapeType::List,
  119         -
        "organization_config_rule_trigger_types",
         119  +
        "OrganizationConfigRuleTriggerTypes",
  120    120   
        1,
  121    121   
    );
  122    122   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  123    123   
    ::aws_smithy_schema::ShapeId::from_static(
  124    124   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$InputParameters",
  125    125   
        "com.amazonaws.configservice",
  126    126   
        "OrganizationCustomPolicyRuleMetadata",
  127    127   
    ),
  128    128   
    ::aws_smithy_schema::ShapeType::String,
  129         -
    "input_parameters",
         129  +
    "InputParameters",
  130    130   
    2,
  131    131   
);
  132    132   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_MAXIMUM_EXECUTION_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  133    133   
    ::aws_smithy_schema::ShapeId::from_static(
  134    134   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$MaximumExecutionFrequency",
  135    135   
        "com.amazonaws.configservice",
  136    136   
        "OrganizationCustomPolicyRuleMetadata",
  137    137   
    ),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "maximum_execution_frequency",
         139  +
    "MaximumExecutionFrequency",
  140    140   
    3,
  141    141   
);
  142    142   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_RESOURCE_TYPES_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  143    143   
    ::aws_smithy_schema::ShapeId::from_static(
  144    144   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$ResourceTypesScope",
  145    145   
        "com.amazonaws.configservice",
  146    146   
        "OrganizationCustomPolicyRuleMetadata",
  147    147   
    ),
  148    148   
    ::aws_smithy_schema::ShapeType::List,
  149         -
    "resource_types_scope",
         149  +
    "ResourceTypesScope",
  150    150   
    4,
  151    151   
);
  152    152   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_RESOURCE_ID_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  153    153   
    ::aws_smithy_schema::ShapeId::from_static(
  154    154   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$ResourceIdScope",
  155    155   
        "com.amazonaws.configservice",
  156    156   
        "OrganizationCustomPolicyRuleMetadata",
  157    157   
    ),
  158    158   
    ::aws_smithy_schema::ShapeType::String,
  159         -
    "resource_id_scope",
         159  +
    "ResourceIdScope",
  160    160   
    5,
  161    161   
);
  162    162   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_TAG_KEY_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  163    163   
    ::aws_smithy_schema::ShapeId::from_static(
  164    164   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$TagKeyScope",
  165    165   
        "com.amazonaws.configservice",
  166    166   
        "OrganizationCustomPolicyRuleMetadata",
  167    167   
    ),
  168    168   
    ::aws_smithy_schema::ShapeType::String,
  169         -
    "tag_key_scope",
         169  +
    "TagKeyScope",
  170    170   
    6,
  171    171   
);
  172    172   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_TAG_VALUE_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  173    173   
    ::aws_smithy_schema::ShapeId::from_static(
  174    174   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$TagValueScope",
  175    175   
        "com.amazonaws.configservice",
  176    176   
        "OrganizationCustomPolicyRuleMetadata",
  177    177   
    ),
  178    178   
    ::aws_smithy_schema::ShapeType::String,
  179         -
    "tag_value_scope",
         179  +
    "TagValueScope",
  180    180   
    7,
  181    181   
);
  182    182   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_POLICY_RUNTIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static(
  184    184   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$PolicyRuntime",
  185    185   
        "com.amazonaws.configservice",
  186    186   
        "OrganizationCustomPolicyRuleMetadata",
  187    187   
    ),
  188    188   
    ::aws_smithy_schema::ShapeType::String,
  189         -
    "policy_runtime",
         189  +
    "PolicyRuntime",
  190    190   
    8,
  191    191   
);
  192    192   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_POLICY_TEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  193    193   
    ::aws_smithy_schema::ShapeId::from_static(
  194    194   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$PolicyText",
  195    195   
        "com.amazonaws.configservice",
  196    196   
        "OrganizationCustomPolicyRuleMetadata",
  197    197   
    ),
  198    198   
    ::aws_smithy_schema::ShapeType::String,
  199         -
    "policy_text",
         199  +
    "PolicyText",
  200    200   
    9,
  201    201   
);
  202    202   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_DEBUG_LOG_DELIVERY_ACCOUNTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  203    203   
    ::aws_smithy_schema::ShapeId::from_static(
  204    204   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadata$DebugLogDeliveryAccounts",
  205    205   
        "com.amazonaws.configservice",
  206    206   
        "OrganizationCustomPolicyRuleMetadata",
  207    207   
    ),
  208    208   
    ::aws_smithy_schema::ShapeType::List,
  209         -
    "debug_log_delivery_accounts",
         209  +
    "DebugLogDeliveryAccounts",
  210    210   
    10,
  211    211   
);
  212    212   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  213    213   
    ORGANIZATIONCUSTOMPOLICYRULEMETADATA_SCHEMA_ID,
  214    214   
    ::aws_smithy_schema::ShapeType::Structure,
  215    215   
    &[
  216    216   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_DESCRIPTION,
  217    217   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES,
  218    218   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_INPUT_PARAMETERS,
  219    219   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATA_MEMBER_MAXIMUM_EXECUTION_FREQUENCY,
@@ -273,273 +420,410 @@
  293    293   
                    }
  294    294   
                    Ok(())
  295    295   
                },
  296    296   
            )?;
  297    297   
        }
  298    298   
        Ok(())
  299    299   
    }
  300    300   
}
  301    301   
impl OrganizationCustomPolicyRuleMetadata {
  302    302   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  303         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  304         -
        deserializer: &mut D,
         303  +
    pub fn deserialize(
         304  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  305    305   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  306    306   
        #[allow(unused_variables, unused_mut)]
  307    307   
        let mut builder = Self::builder();
  308    308   
        #[allow(
  309    309   
            unused_variables,
  310    310   
            unreachable_code,
  311    311   
            clippy::single_match,
  312    312   
            clippy::match_single_binding,
  313    313   
            clippy::diverging_sub_expression
  314    314   
        )]
  315         -
        deserializer.read_struct(&ORGANIZATIONCUSTOMPOLICYRULEMETADATA_SCHEMA, (), |_, member, deser| {
         315  +
        deserializer.read_struct(&ORGANIZATIONCUSTOMPOLICYRULEMETADATA_SCHEMA, &mut |member, deser| {
  316    316   
            match member.member_index() {
  317    317   
                Some(0) => {
  318    318   
                    builder.description = Some(deser.read_string(member)?);
  319    319   
                }
  320    320   
                Some(1) => {
  321    321   
                    builder.organization_config_rule_trigger_types = Some({
  322         -
                        let container = if let Some(cap) = deser.container_size() {
  323         -
                            Vec::with_capacity(cap)
  324         -
                        } else {
  325         -
                            Vec::new()
  326         -
                        };
  327         -
                        deser.read_list(member, container, |mut list, deser| {
  328         -
                            list.push(crate::types::OrganizationConfigRuleTriggerTypeNoSn::from(
         322  +
                        let mut container = Vec::new();
         323  +
                        deser.read_list(member, &mut |deser| {
         324  +
                            container.push(crate::types::OrganizationConfigRuleTriggerTypeNoSn::from(
  329    325   
                                deser.read_string(member)?.as_str(),
  330    326   
                            ));
  331         -
                            Ok(list)
  332         -
                        })?
         327  +
                            Ok(())
         328  +
                        })?;
         329  +
                        container
  333    330   
                    });
  334    331   
                }
  335    332   
                Some(2) => {
  336    333   
                    builder.input_parameters = Some(deser.read_string(member)?);
  337    334   
                }
  338    335   
                Some(3) => {
  339    336   
                    builder.maximum_execution_frequency = Some(crate::types::MaximumExecutionFrequency::from(deser.read_string(member)?.as_str()));
  340    337   
                }
  341    338   
                Some(4) => {
  342         -
                    builder.resource_types_scope = Some({
  343         -
                        let container = if let Some(cap) = deser.container_size() {
  344         -
                            Vec::with_capacity(cap)
  345         -
                        } else {
  346         -
                            Vec::new()
  347         -
                        };
  348         -
                        deser.read_list(member, container, |mut list, deser| {
  349         -
                            list.push(deser.read_string(member)?);
  350         -
                            Ok(list)
  351         -
                        })?
  352         -
                    });
         339  +
                    builder.resource_types_scope = Some(deser.read_string_list(member)?);
  353    340   
                }
  354    341   
                Some(5) => {
  355    342   
                    builder.resource_id_scope = Some(deser.read_string(member)?);
  356    343   
                }
  357    344   
                Some(6) => {
  358    345   
                    builder.tag_key_scope = Some(deser.read_string(member)?);
  359    346   
                }
  360    347   
                Some(7) => {
  361    348   
                    builder.tag_value_scope = Some(deser.read_string(member)?);
  362    349   
                }
  363    350   
                Some(8) => {
  364    351   
                    builder.policy_runtime = Some(deser.read_string(member)?);
  365    352   
                }
  366    353   
                Some(9) => {
  367    354   
                    builder.policy_text = Some(deser.read_string(member)?);
  368    355   
                }
  369    356   
                Some(10) => {
  370         -
                    builder.debug_log_delivery_accounts = Some({
  371         -
                        let container = if let Some(cap) = deser.container_size() {
  372         -
                            Vec::with_capacity(cap)
  373         -
                        } else {
  374         -
                            Vec::new()
  375         -
                        };
  376         -
                        deser.read_list(member, container, |mut list, deser| {
  377         -
                            list.push(deser.read_string(member)?);
  378         -
                            Ok(list)
  379         -
                        })?
  380         -
                    });
         357  +
                    builder.debug_log_delivery_accounts = Some(deser.read_string_list(member)?);
  381    358   
                }
  382    359   
                _ => {}
  383    360   
            }
  384    361   
            Ok(())
  385    362   
        })?;
         363  +
        builder.policy_runtime = builder.policy_runtime.or(Some(String::new()));
         364  +
        builder.policy_text = builder.policy_text.or(Some(String::new()));
  386    365   
        builder
  387    366   
            .build()
  388    367   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  389    368   
    }
  390    369   
}
         370  +
impl OrganizationCustomPolicyRuleMetadata {
         371  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         372  +
    pub fn deserialize_with_response(
         373  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         374  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         375  +
        _status: u16,
         376  +
        _body: &[u8],
         377  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         378  +
        Self::deserialize(deserializer)
         379  +
    }
         380  +
}
  391    381   
impl OrganizationCustomPolicyRuleMetadata {
  392    382   
    /// Creates a new builder-style object to manufacture [`OrganizationCustomPolicyRuleMetadata`](crate::types::OrganizationCustomPolicyRuleMetadata).
  393    383   
    pub fn builder() -> crate::types::builders::OrganizationCustomPolicyRuleMetadataBuilder {
  394    384   
        crate::types::builders::OrganizationCustomPolicyRuleMetadataBuilder::default()
  395    385   
    }
  396    386   
}
  397    387   
  398    388   
/// A builder for [`OrganizationCustomPolicyRuleMetadata`](crate::types::OrganizationCustomPolicyRuleMetadata).
  399    389   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  400    390   
#[non_exhaustive]

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

@@ -70,70 +224,224 @@
   90     90   
    "com.amazonaws.configservice",
   91     91   
    "OrganizationCustomPolicyRuleMetadataNoPolicy",
   92     92   
);
   93     93   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$Description",
   96     96   
        "com.amazonaws.configservice",
   97     97   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "description",
         100  +
    "Description",
  101    101   
    0,
  102    102   
);
  103    103   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES: ::aws_smithy_schema::Schema =
  104    104   
    ::aws_smithy_schema::Schema::new_member(
  105    105   
        ::aws_smithy_schema::ShapeId::from_static(
  106    106   
            "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$OrganizationConfigRuleTriggerTypes",
  107    107   
            "com.amazonaws.configservice",
  108    108   
            "OrganizationCustomPolicyRuleMetadataNoPolicy",
  109    109   
        ),
  110    110   
        ::aws_smithy_schema::ShapeType::List,
  111         -
        "organization_config_rule_trigger_types",
         111  +
        "OrganizationConfigRuleTriggerTypes",
  112    112   
        1,
  113    113   
    );
  114    114   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$InputParameters",
  117    117   
        "com.amazonaws.configservice",
  118    118   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "input_parameters",
         121  +
    "InputParameters",
  122    122   
    2,
  123    123   
);
  124    124   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_MAXIMUM_EXECUTION_FREQUENCY: ::aws_smithy_schema::Schema =
  125    125   
    ::aws_smithy_schema::Schema::new_member(
  126    126   
        ::aws_smithy_schema::ShapeId::from_static(
  127    127   
            "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$MaximumExecutionFrequency",
  128    128   
            "com.amazonaws.configservice",
  129    129   
            "OrganizationCustomPolicyRuleMetadataNoPolicy",
  130    130   
        ),
  131    131   
        ::aws_smithy_schema::ShapeType::String,
  132         -
        "maximum_execution_frequency",
         132  +
        "MaximumExecutionFrequency",
  133    133   
        3,
  134    134   
    );
  135    135   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_RESOURCE_TYPES_SCOPE: ::aws_smithy_schema::Schema =
  136    136   
    ::aws_smithy_schema::Schema::new_member(
  137    137   
        ::aws_smithy_schema::ShapeId::from_static(
  138    138   
            "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$ResourceTypesScope",
  139    139   
            "com.amazonaws.configservice",
  140    140   
            "OrganizationCustomPolicyRuleMetadataNoPolicy",
  141    141   
        ),
  142    142   
        ::aws_smithy_schema::ShapeType::List,
  143         -
        "resource_types_scope",
         143  +
        "ResourceTypesScope",
  144    144   
        4,
  145    145   
    );
  146    146   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_RESOURCE_ID_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$ResourceIdScope",
  149    149   
        "com.amazonaws.configservice",
  150    150   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "resource_id_scope",
         153  +
    "ResourceIdScope",
  154    154   
    5,
  155    155   
);
  156    156   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_TAG_KEY_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$TagKeyScope",
  159    159   
        "com.amazonaws.configservice",
  160    160   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "tag_key_scope",
         163  +
    "TagKeyScope",
  164    164   
    6,
  165    165   
);
  166    166   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_TAG_VALUE_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$TagValueScope",
  169    169   
        "com.amazonaws.configservice",
  170    170   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::String,
  173         -
    "tag_value_scope",
         173  +
    "TagValueScope",
  174    174   
    7,
  175    175   
);
  176    176   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_POLICY_RUNTIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$PolicyRuntime",
  179    179   
        "com.amazonaws.configservice",
  180    180   
        "OrganizationCustomPolicyRuleMetadataNoPolicy",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::String,
  183         -
    "policy_runtime",
         183  +
    "PolicyRuntime",
  184    184   
    8,
  185    185   
);
  186    186   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_DEBUG_LOG_DELIVERY_ACCOUNTS: ::aws_smithy_schema::Schema =
  187    187   
    ::aws_smithy_schema::Schema::new_member(
  188    188   
        ::aws_smithy_schema::ShapeId::from_static(
  189    189   
            "com.amazonaws.configservice#OrganizationCustomPolicyRuleMetadataNoPolicy$DebugLogDeliveryAccounts",
  190    190   
            "com.amazonaws.configservice",
  191    191   
            "OrganizationCustomPolicyRuleMetadataNoPolicy",
  192    192   
        ),
  193    193   
        ::aws_smithy_schema::ShapeType::List,
  194         -
        "debug_log_delivery_accounts",
         194  +
        "DebugLogDeliveryAccounts",
  195    195   
        9,
  196    196   
    );
  197    197   
static ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  198    198   
    ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_SCHEMA_ID,
  199    199   
    ::aws_smithy_schema::ShapeType::Structure,
  200    200   
    &[
  201    201   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_DESCRIPTION,
  202    202   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES,
  203    203   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_INPUT_PARAMETERS,
  204    204   
        &ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_MEMBER_MAXIMUM_EXECUTION_FREQUENCY,
@@ -255,255 +397,385 @@
  275    275   
                    }
  276    276   
                    Ok(())
  277    277   
                },
  278    278   
            )?;
  279    279   
        }
  280    280   
        Ok(())
  281    281   
    }
  282    282   
}
  283    283   
impl OrganizationCustomPolicyRuleMetadataNoPolicy {
  284    284   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  285         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  286         -
        deserializer: &mut D,
         285  +
    pub fn deserialize(
         286  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  287    287   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  288    288   
        #[allow(unused_variables, unused_mut)]
  289    289   
        let mut builder = Self::builder();
  290    290   
        #[allow(
  291    291   
            unused_variables,
  292    292   
            unreachable_code,
  293    293   
            clippy::single_match,
  294    294   
            clippy::match_single_binding,
  295    295   
            clippy::diverging_sub_expression
  296    296   
        )]
  297         -
        deserializer.read_struct(&ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_SCHEMA, (), |_, member, deser| {
         297  +
        deserializer.read_struct(&ORGANIZATIONCUSTOMPOLICYRULEMETADATANOPOLICY_SCHEMA, &mut |member, deser| {
  298    298   
            match member.member_index() {
  299    299   
                Some(0) => {
  300    300   
                    builder.description = Some(deser.read_string(member)?);
  301    301   
                }
  302    302   
                Some(1) => {
  303    303   
                    builder.organization_config_rule_trigger_types = Some({
  304         -
                        let container = if let Some(cap) = deser.container_size() {
  305         -
                            Vec::with_capacity(cap)
  306         -
                        } else {
  307         -
                            Vec::new()
  308         -
                        };
  309         -
                        deser.read_list(member, container, |mut list, deser| {
  310         -
                            list.push(crate::types::OrganizationConfigRuleTriggerTypeNoSn::from(
         304  +
                        let mut container = Vec::new();
         305  +
                        deser.read_list(member, &mut |deser| {
         306  +
                            container.push(crate::types::OrganizationConfigRuleTriggerTypeNoSn::from(
  311    307   
                                deser.read_string(member)?.as_str(),
  312    308   
                            ));
  313         -
                            Ok(list)
  314         -
                        })?
         309  +
                            Ok(())
         310  +
                        })?;
         311  +
                        container
  315    312   
                    });
  316    313   
                }
  317    314   
                Some(2) => {
  318    315   
                    builder.input_parameters = Some(deser.read_string(member)?);
  319    316   
                }
  320    317   
                Some(3) => {
  321    318   
                    builder.maximum_execution_frequency = Some(crate::types::MaximumExecutionFrequency::from(deser.read_string(member)?.as_str()));
  322    319   
                }
  323    320   
                Some(4) => {
  324         -
                    builder.resource_types_scope = Some({
  325         -
                        let container = if let Some(cap) = deser.container_size() {
  326         -
                            Vec::with_capacity(cap)
  327         -
                        } else {
  328         -
                            Vec::new()
  329         -
                        };
  330         -
                        deser.read_list(member, container, |mut list, deser| {
  331         -
                            list.push(deser.read_string(member)?);
  332         -
                            Ok(list)
  333         -
                        })?
  334         -
                    });
         321  +
                    builder.resource_types_scope = Some(deser.read_string_list(member)?);
  335    322   
                }
  336    323   
                Some(5) => {
  337    324   
                    builder.resource_id_scope = Some(deser.read_string(member)?);
  338    325   
                }
  339    326   
                Some(6) => {
  340    327   
                    builder.tag_key_scope = Some(deser.read_string(member)?);
  341    328   
                }
  342    329   
                Some(7) => {
  343    330   
                    builder.tag_value_scope = Some(deser.read_string(member)?);
  344    331   
                }
  345    332   
                Some(8) => {
  346    333   
                    builder.policy_runtime = Some(deser.read_string(member)?);
  347    334   
                }
  348    335   
                Some(9) => {
  349         -
                    builder.debug_log_delivery_accounts = Some({
  350         -
                        let container = if let Some(cap) = deser.container_size() {
  351         -
                            Vec::with_capacity(cap)
  352         -
                        } else {
  353         -
                            Vec::new()
  354         -
                        };
  355         -
                        deser.read_list(member, container, |mut list, deser| {
  356         -
                            list.push(deser.read_string(member)?);
  357         -
                            Ok(list)
  358         -
                        })?
  359         -
                    });
         336  +
                    builder.debug_log_delivery_accounts = Some(deser.read_string_list(member)?);
  360    337   
                }
  361    338   
                _ => {}
  362    339   
            }
  363    340   
            Ok(())
  364    341   
        })?;
  365    342   
        Ok(builder.build())
  366    343   
    }
  367    344   
}
         345  +
impl OrganizationCustomPolicyRuleMetadataNoPolicy {
         346  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         347  +
    pub fn deserialize_with_response(
         348  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         349  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         350  +
        _status: u16,
         351  +
        _body: &[u8],
         352  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         353  +
        Self::deserialize(deserializer)
         354  +
    }
         355  +
}
  368    356   
impl OrganizationCustomPolicyRuleMetadataNoPolicy {
  369    357   
    /// Creates a new builder-style object to manufacture [`OrganizationCustomPolicyRuleMetadataNoPolicy`](crate::types::OrganizationCustomPolicyRuleMetadataNoPolicy).
  370    358   
    pub fn builder() -> crate::types::builders::OrganizationCustomPolicyRuleMetadataNoPolicyBuilder {
  371    359   
        crate::types::builders::OrganizationCustomPolicyRuleMetadataNoPolicyBuilder::default()
  372    360   
    }
  373    361   
}
  374    362   
  375    363   
/// A builder for [`OrganizationCustomPolicyRuleMetadataNoPolicy`](crate::types::OrganizationCustomPolicyRuleMetadataNoPolicy).
  376    364   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  377    365   
#[non_exhaustive]

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

@@ -70,70 +211,211 @@
   90     90   
    "com.amazonaws.configservice",
   91     91   
    "OrganizationCustomRuleMetadata",
   92     92   
);
   93     93   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   94     94   
    ::aws_smithy_schema::ShapeId::from_static(
   95     95   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$Description",
   96     96   
        "com.amazonaws.configservice",
   97     97   
        "OrganizationCustomRuleMetadata",
   98     98   
    ),
   99     99   
    ::aws_smithy_schema::ShapeType::String,
  100         -
    "description",
         100  +
    "Description",
  101    101   
    0,
  102    102   
);
  103    103   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_LAMBDA_FUNCTION_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$LambdaFunctionArn",
  106    106   
        "com.amazonaws.configservice",
  107    107   
        "OrganizationCustomRuleMetadata",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::String,
  110         -
    "lambda_function_arn",
         110  +
    "LambdaFunctionArn",
  111    111   
    1,
  112    112   
);
  113    113   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES: ::aws_smithy_schema::Schema =
  114    114   
    ::aws_smithy_schema::Schema::new_member(
  115    115   
        ::aws_smithy_schema::ShapeId::from_static(
  116    116   
            "com.amazonaws.configservice#OrganizationCustomRuleMetadata$OrganizationConfigRuleTriggerTypes",
  117    117   
            "com.amazonaws.configservice",
  118    118   
            "OrganizationCustomRuleMetadata",
  119    119   
        ),
  120    120   
        ::aws_smithy_schema::ShapeType::List,
  121         -
        "organization_config_rule_trigger_types",
         121  +
        "OrganizationConfigRuleTriggerTypes",
  122    122   
        2,
  123    123   
    );
  124    124   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  125    125   
    ::aws_smithy_schema::ShapeId::from_static(
  126    126   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$InputParameters",
  127    127   
        "com.amazonaws.configservice",
  128    128   
        "OrganizationCustomRuleMetadata",
  129    129   
    ),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "input_parameters",
         131  +
    "InputParameters",
  132    132   
    3,
  133    133   
);
  134    134   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_MAXIMUM_EXECUTION_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$MaximumExecutionFrequency",
  137    137   
        "com.amazonaws.configservice",
  138    138   
        "OrganizationCustomRuleMetadata",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "maximum_execution_frequency",
         141  +
    "MaximumExecutionFrequency",
  142    142   
    4,
  143    143   
);
  144    144   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_RESOURCE_TYPES_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  145    145   
    ::aws_smithy_schema::ShapeId::from_static(
  146    146   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$ResourceTypesScope",
  147    147   
        "com.amazonaws.configservice",
  148    148   
        "OrganizationCustomRuleMetadata",
  149    149   
    ),
  150    150   
    ::aws_smithy_schema::ShapeType::List,
  151         -
    "resource_types_scope",
         151  +
    "ResourceTypesScope",
  152    152   
    5,
  153    153   
);
  154    154   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_RESOURCE_ID_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static(
  156    156   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$ResourceIdScope",
  157    157   
        "com.amazonaws.configservice",
  158    158   
        "OrganizationCustomRuleMetadata",
  159    159   
    ),
  160    160   
    ::aws_smithy_schema::ShapeType::String,
  161         -
    "resource_id_scope",
         161  +
    "ResourceIdScope",
  162    162   
    6,
  163    163   
);
  164    164   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_TAG_KEY_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static(
  166    166   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$TagKeyScope",
  167    167   
        "com.amazonaws.configservice",
  168    168   
        "OrganizationCustomRuleMetadata",
  169    169   
    ),
  170    170   
    ::aws_smithy_schema::ShapeType::String,
  171         -
    "tag_key_scope",
         171  +
    "TagKeyScope",
  172    172   
    7,
  173    173   
);
  174    174   
static ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_TAG_VALUE_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  175    175   
    ::aws_smithy_schema::ShapeId::from_static(
  176    176   
        "com.amazonaws.configservice#OrganizationCustomRuleMetadata$TagValueScope",
  177    177   
        "com.amazonaws.configservice",
  178    178   
        "OrganizationCustomRuleMetadata",
  179    179   
    ),
  180    180   
    ::aws_smithy_schema::ShapeType::String,
  181         -
    "tag_value_scope",
         181  +
    "TagValueScope",
  182    182   
    8,
  183    183   
);
  184    184   
static ORGANIZATIONCUSTOMRULEMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  185    185   
    ORGANIZATIONCUSTOMRULEMETADATA_SCHEMA_ID,
  186    186   
    ::aws_smithy_schema::ShapeType::Structure,
  187    187   
    &[
  188    188   
        &ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_DESCRIPTION,
  189    189   
        &ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_LAMBDA_FUNCTION_ARN,
  190    190   
        &ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_ORGANIZATION_CONFIG_RULE_TRIGGER_TYPES,
  191    191   
        &ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_INPUT_PARAMETERS,
@@ -230,230 +359,359 @@
  250    250   
            ser.write_string(&ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_TAG_KEY_SCOPE, val)?;
  251    251   
        }
  252    252   
        if let Some(ref val) = self.tag_value_scope {
  253    253   
            ser.write_string(&ORGANIZATIONCUSTOMRULEMETADATA_MEMBER_TAG_VALUE_SCOPE, val)?;
  254    254   
        }
  255    255   
        Ok(())
  256    256   
    }
  257    257   
}
  258    258   
impl OrganizationCustomRuleMetadata {
  259    259   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  260         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  261         -
        deserializer: &mut D,
         260  +
    pub fn deserialize(
         261  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  262    262   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  263    263   
        #[allow(unused_variables, unused_mut)]
  264    264   
        let mut builder = Self::builder();
  265    265   
        #[allow(
  266    266   
            unused_variables,
  267    267   
            unreachable_code,
  268    268   
            clippy::single_match,
  269    269   
            clippy::match_single_binding,
  270    270   
            clippy::diverging_sub_expression
  271    271   
        )]
  272         -
        deserializer.read_struct(&ORGANIZATIONCUSTOMRULEMETADATA_SCHEMA, (), |_, member, deser| {
         272  +
        deserializer.read_struct(&ORGANIZATIONCUSTOMRULEMETADATA_SCHEMA, &mut |member, deser| {
  273    273   
            match member.member_index() {
  274    274   
                Some(0) => {
  275    275   
                    builder.description = Some(deser.read_string(member)?);
  276    276   
                }
  277    277   
                Some(1) => {
  278    278   
                    builder.lambda_function_arn = Some(deser.read_string(member)?);
  279    279   
                }
  280    280   
                Some(2) => {
  281    281   
                    builder.organization_config_rule_trigger_types = Some({
  282         -
                        let container = if let Some(cap) = deser.container_size() {
  283         -
                            Vec::with_capacity(cap)
  284         -
                        } else {
  285         -
                            Vec::new()
  286         -
                        };
  287         -
                        deser.read_list(member, container, |mut list, deser| {
  288         -
                            list.push(crate::types::OrganizationConfigRuleTriggerType::from(deser.read_string(member)?.as_str()));
  289         -
                            Ok(list)
  290         -
                        })?
         282  +
                        let mut container = Vec::new();
         283  +
                        deser.read_list(member, &mut |deser| {
         284  +
                            container.push(crate::types::OrganizationConfigRuleTriggerType::from(deser.read_string(member)?.as_str()));
         285  +
                            Ok(())
         286  +
                        })?;
         287  +
                        container
  291    288   
                    });
  292    289   
                }
  293    290   
                Some(3) => {
  294    291   
                    builder.input_parameters = Some(deser.read_string(member)?);
  295    292   
                }
  296    293   
                Some(4) => {
  297    294   
                    builder.maximum_execution_frequency = Some(crate::types::MaximumExecutionFrequency::from(deser.read_string(member)?.as_str()));
  298    295   
                }
  299    296   
                Some(5) => {
  300         -
                    builder.resource_types_scope = Some({
  301         -
                        let container = if let Some(cap) = deser.container_size() {
  302         -
                            Vec::with_capacity(cap)
  303         -
                        } else {
  304         -
                            Vec::new()
  305         -
                        };
  306         -
                        deser.read_list(member, container, |mut list, deser| {
  307         -
                            list.push(deser.read_string(member)?);
  308         -
                            Ok(list)
  309         -
                        })?
  310         -
                    });
         297  +
                    builder.resource_types_scope = Some(deser.read_string_list(member)?);
  311    298   
                }
  312    299   
                Some(6) => {
  313    300   
                    builder.resource_id_scope = Some(deser.read_string(member)?);
  314    301   
                }
  315    302   
                Some(7) => {
  316    303   
                    builder.tag_key_scope = Some(deser.read_string(member)?);
  317    304   
                }
  318    305   
                Some(8) => {
  319    306   
                    builder.tag_value_scope = Some(deser.read_string(member)?);
  320    307   
                }
  321    308   
                _ => {}
  322    309   
            }
  323    310   
            Ok(())
  324    311   
        })?;
         312  +
        builder.lambda_function_arn = builder.lambda_function_arn.or(Some(String::new()));
         313  +
        builder.organization_config_rule_trigger_types = builder.organization_config_rule_trigger_types.or(Some(Vec::new()));
  325    314   
        builder
  326    315   
            .build()
  327    316   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  328    317   
    }
  329    318   
}
         319  +
impl OrganizationCustomRuleMetadata {
         320  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         321  +
    pub fn deserialize_with_response(
         322  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         323  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         324  +
        _status: u16,
         325  +
        _body: &[u8],
         326  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         327  +
        Self::deserialize(deserializer)
         328  +
    }
         329  +
}
  330    330   
impl OrganizationCustomRuleMetadata {
  331    331   
    /// Creates a new builder-style object to manufacture [`OrganizationCustomRuleMetadata`](crate::types::OrganizationCustomRuleMetadata).
  332    332   
    pub fn builder() -> crate::types::builders::OrganizationCustomRuleMetadataBuilder {
  333    333   
        crate::types::builders::OrganizationCustomRuleMetadataBuilder::default()
  334    334   
    }
  335    335   
}
  336    336   
  337    337   
/// A builder for [`OrganizationCustomRuleMetadata`](crate::types::OrganizationCustomRuleMetadata).
  338    338   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  339    339   
#[non_exhaustive]

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

@@ -47,47 +177,177 @@
   67     67   
    "com.amazonaws.configservice",
   68     68   
    "OrganizationManagedRuleMetadata",
   69     69   
);
   70     70   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$Description",
   73     73   
        "com.amazonaws.configservice",
   74     74   
        "OrganizationManagedRuleMetadata",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "description",
          77  +
    "Description",
   78     78   
    0,
   79     79   
);
   80     80   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_RULE_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$RuleIdentifier",
   83     83   
        "com.amazonaws.configservice",
   84     84   
        "OrganizationManagedRuleMetadata",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "rule_identifier",
          87  +
    "RuleIdentifier",
   88     88   
    1,
   89     89   
);
   90     90   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_INPUT_PARAMETERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$InputParameters",
   93     93   
        "com.amazonaws.configservice",
   94     94   
        "OrganizationManagedRuleMetadata",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "input_parameters",
          97  +
    "InputParameters",
   98     98   
    2,
   99     99   
);
  100    100   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_MAXIMUM_EXECUTION_FREQUENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$MaximumExecutionFrequency",
  103    103   
        "com.amazonaws.configservice",
  104    104   
        "OrganizationManagedRuleMetadata",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "maximum_execution_frequency",
         107  +
    "MaximumExecutionFrequency",
  108    108   
    3,
  109    109   
);
  110    110   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_RESOURCE_TYPES_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$ResourceTypesScope",
  113    113   
        "com.amazonaws.configservice",
  114    114   
        "OrganizationManagedRuleMetadata",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::List,
  117         -
    "resource_types_scope",
         117  +
    "ResourceTypesScope",
  118    118   
    4,
  119    119   
);
  120    120   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_RESOURCE_ID_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$ResourceIdScope",
  123    123   
        "com.amazonaws.configservice",
  124    124   
        "OrganizationManagedRuleMetadata",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::String,
  127         -
    "resource_id_scope",
         127  +
    "ResourceIdScope",
  128    128   
    5,
  129    129   
);
  130    130   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_TAG_KEY_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$TagKeyScope",
  133    133   
        "com.amazonaws.configservice",
  134    134   
        "OrganizationManagedRuleMetadata",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "tag_key_scope",
         137  +
    "TagKeyScope",
  138    138   
    6,
  139    139   
);
  140    140   
static ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_TAG_VALUE_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.configservice#OrganizationManagedRuleMetadata$TagValueScope",
  143    143   
        "com.amazonaws.configservice",
  144    144   
        "OrganizationManagedRuleMetadata",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "tag_value_scope",
         147  +
    "TagValueScope",
  148    148   
    7,
  149    149   
);
  150    150   
static ORGANIZATIONMANAGEDRULEMETADATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  151    151   
    ORGANIZATIONMANAGEDRULEMETADATA_SCHEMA_ID,
  152    152   
    ::aws_smithy_schema::ShapeType::Structure,
  153    153   
    &[
  154    154   
        &ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_DESCRIPTION,
  155    155   
        &ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_RULE_IDENTIFIER,
  156    156   
        &ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_INPUT_PARAMETERS,
  157    157   
        &ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_MAXIMUM_EXECUTION_FREQUENCY,
@@ -182,182 +298,300 @@
  202    202   
            ser.write_string(&ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_TAG_KEY_SCOPE, val)?;
  203    203   
        }
  204    204   
        if let Some(ref val) = self.tag_value_scope {
  205    205   
            ser.write_string(&ORGANIZATIONMANAGEDRULEMETADATA_MEMBER_TAG_VALUE_SCOPE, val)?;
  206    206   
        }
  207    207   
        Ok(())
  208    208   
    }
  209    209   
}
  210    210   
impl OrganizationManagedRuleMetadata {
  211    211   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  212         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  213         -
        deserializer: &mut D,
         212  +
    pub fn deserialize(
         213  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  214    214   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  215    215   
        #[allow(unused_variables, unused_mut)]
  216    216   
        let mut builder = Self::builder();
  217    217   
        #[allow(
  218    218   
            unused_variables,
  219    219   
            unreachable_code,
  220    220   
            clippy::single_match,
  221    221   
            clippy::match_single_binding,
  222    222   
            clippy::diverging_sub_expression
  223    223   
        )]
  224         -
        deserializer.read_struct(&ORGANIZATIONMANAGEDRULEMETADATA_SCHEMA, (), |_, member, deser| {
         224  +
        deserializer.read_struct(&ORGANIZATIONMANAGEDRULEMETADATA_SCHEMA, &mut |member, deser| {
  225    225   
            match member.member_index() {
  226    226   
                Some(0) => {
  227    227   
                    builder.description = Some(deser.read_string(member)?);
  228    228   
                }
  229    229   
                Some(1) => {
  230    230   
                    builder.rule_identifier = Some(deser.read_string(member)?);
  231    231   
                }
  232    232   
                Some(2) => {
  233    233   
                    builder.input_parameters = Some(deser.read_string(member)?);
  234    234   
                }
  235    235   
                Some(3) => {
  236    236   
                    builder.maximum_execution_frequency = Some(crate::types::MaximumExecutionFrequency::from(deser.read_string(member)?.as_str()));
  237    237   
                }
  238    238   
                Some(4) => {
  239         -
                    builder.resource_types_scope = Some({
  240         -
                        let container = if let Some(cap) = deser.container_size() {
  241         -
                            Vec::with_capacity(cap)
  242         -
                        } else {
  243         -
                            Vec::new()
  244         -
                        };
  245         -
                        deser.read_list(member, container, |mut list, deser| {
  246         -
                            list.push(deser.read_string(member)?);
  247         -
                            Ok(list)
  248         -
                        })?
  249         -
                    });
         239  +
                    builder.resource_types_scope = Some(deser.read_string_list(member)?);
  250    240   
                }
  251    241   
                Some(5) => {
  252    242   
                    builder.resource_id_scope = Some(deser.read_string(member)?);
  253    243   
                }
  254    244   
                Some(6) => {
  255    245   
                    builder.tag_key_scope = Some(deser.read_string(member)?);
  256    246   
                }
  257    247   
                Some(7) => {
  258    248   
                    builder.tag_value_scope = Some(deser.read_string(member)?);
  259    249   
                }
  260    250   
                _ => {}
  261    251   
            }
  262    252   
            Ok(())
  263    253   
        })?;
         254  +
        builder.rule_identifier = builder.rule_identifier.or(Some(String::new()));
  264    255   
        builder
  265    256   
            .build()
  266    257   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  267    258   
    }
  268    259   
}
         260  +
impl OrganizationManagedRuleMetadata {
         261  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         262  +
    pub fn deserialize_with_response(
         263  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         264  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         265  +
        _status: u16,
         266  +
        _body: &[u8],
         267  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         268  +
        Self::deserialize(deserializer)
         269  +
    }
         270  +
}
  269    271   
impl OrganizationManagedRuleMetadata {
  270    272   
    /// Creates a new builder-style object to manufacture [`OrganizationManagedRuleMetadata`](crate::types::OrganizationManagedRuleMetadata).
  271    273   
    pub fn builder() -> crate::types::builders::OrganizationManagedRuleMetadataBuilder {
  272    274   
        crate::types::builders::OrganizationManagedRuleMetadataBuilder::default()
  273    275   
    }
  274    276   
}
  275    277   
  276    278   
/// A builder for [`OrganizationManagedRuleMetadata`](crate::types::OrganizationManagedRuleMetadata).
  277    279   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  278    280   
#[non_exhaustive]

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

@@ -46,46 +176,187 @@
   66     66   
    "com.amazonaws.configservice",
   67     67   
    "OrganizationResourceDetailedStatusFilters",
   68     68   
);
   69     69   
static ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_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#OrganizationResourceDetailedStatusFilters$AccountId",
   72     72   
        "com.amazonaws.configservice",
   73     73   
        "OrganizationResourceDetailedStatusFilters",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "account_id",
          76  +
    "AccountId",
   77     77   
    0,
   78     78   
);
   79     79   
static ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.configservice#OrganizationResourceDetailedStatusFilters$Status",
   82     82   
        "com.amazonaws.configservice",
   83     83   
        "OrganizationResourceDetailedStatusFilters",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "status",
          86  +
    "Status",
   87     87   
    1,
   88     88   
);
   89     89   
static ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   90     90   
    ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_SCHEMA_ID,
   91     91   
    ::aws_smithy_schema::ShapeType::Structure,
   92     92   
    &[
   93     93   
        &ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_MEMBER_ACCOUNT_ID,
   94     94   
        &ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_MEMBER_STATUS,
   95     95   
    ],
   96     96   
);
   97     97   
impl OrganizationResourceDetailedStatusFilters {
   98     98   
    /// The schema for this shape.
   99     99   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_SCHEMA;
  100    100   
}
  101    101   
impl ::aws_smithy_schema::serde::SerializableStruct for OrganizationResourceDetailedStatusFilters {
  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(&ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_MEMBER_ACCOUNT_ID, val)?;
  109    109   
        }
  110    110   
        if let Some(ref val) = self.status {
  111    111   
            ser.write_string(&ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_MEMBER_STATUS, val.as_str())?;
  112    112   
        }
  113    113   
        Ok(())
  114    114   
    }
  115    115   
}
  116    116   
impl OrganizationResourceDetailedStatusFilters {
  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(&ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_SCHEMA, (), |_, member, deser| {
         130  +
        deserializer.read_struct(&ORGANIZATIONRESOURCEDETAILEDSTATUSFILTERS_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.status = Some(crate::types::OrganizationResourceDetailedStatus::from(
  137    137   
                        deser.read_string(member)?.as_str(),
  138    138   
                    ));
  139    139   
                }
  140    140   
                _ => {}
  141    141   
            }
  142    142   
            Ok(())
  143    143   
        })?;
  144    144   
        Ok(builder.build())
  145    145   
    }
  146    146   
}
         147  +
impl OrganizationResourceDetailedStatusFilters {
         148  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         149  +
    pub fn deserialize_with_response(
         150  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         151  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         152  +
        _status: u16,
         153  +
        _body: &[u8],
         154  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         155  +
        Self::deserialize(deserializer)
         156  +
    }
         157  +
}
  147    158   
impl OrganizationResourceDetailedStatusFilters {
  148    159   
    /// Creates a new builder-style object to manufacture [`OrganizationResourceDetailedStatusFilters`](crate::types::OrganizationResourceDetailedStatusFilters).
  149    160   
    pub fn builder() -> crate::types::builders::OrganizationResourceDetailedStatusFiltersBuilder {
  150    161   
        crate::types::builders::OrganizationResourceDetailedStatusFiltersBuilder::default()
  151    162   
    }
  152    163   
}
  153    164   
  154    165   
/// A builder for [`OrganizationResourceDetailedStatusFilters`](crate::types::OrganizationResourceDetailedStatusFilters).
  155    166   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  156    167   
#[non_exhaustive]

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

@@ -4,4 +132,143 @@
   24     24   
    "com.amazonaws.configservice",
   25     25   
    "PendingAggregationRequest",
   26     26   
);
   27     27   
static PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   28     28   
    ::aws_smithy_schema::ShapeId::from_static(
   29     29   
        "com.amazonaws.configservice#PendingAggregationRequest$RequesterAccountId",
   30     30   
        "com.amazonaws.configservice",
   31     31   
        "PendingAggregationRequest",
   32     32   
    ),
   33     33   
    ::aws_smithy_schema::ShapeType::String,
   34         -
    "requester_account_id",
          34  +
    "RequesterAccountId",
   35     35   
    0,
   36     36   
);
   37     37   
static PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_AWS_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   38     38   
    ::aws_smithy_schema::ShapeId::from_static(
   39     39   
        "com.amazonaws.configservice#PendingAggregationRequest$RequesterAwsRegion",
   40     40   
        "com.amazonaws.configservice",
   41     41   
        "PendingAggregationRequest",
   42     42   
    ),
   43     43   
    ::aws_smithy_schema::ShapeType::String,
   44         -
    "requester_aws_region",
          44  +
    "RequesterAwsRegion",
   45     45   
    1,
   46     46   
);
   47     47   
static PENDINGAGGREGATIONREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    PENDINGAGGREGATIONREQUEST_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_ACCOUNT_ID,
   52     52   
        &PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_AWS_REGION,
   53     53   
    ],
   54     54   
);
   55     55   
impl PendingAggregationRequest {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &PENDINGAGGREGATIONREQUEST_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for PendingAggregationRequest {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        if let Some(ref val) = self.requester_account_id {
   66     66   
            ser.write_string(&PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_ACCOUNT_ID, val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.requester_aws_region {
   69     69   
            ser.write_string(&PENDINGAGGREGATIONREQUEST_MEMBER_REQUESTER_AWS_REGION, val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl PendingAggregationRequest {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&PENDINGAGGREGATIONREQUEST_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&PENDINGAGGREGATIONREQUEST_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.requester_account_id = Some(deser.read_string(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.requester_aws_region = Some(deser.read_string(member)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
  100    100   
        Ok(builder.build())
  101    101   
    }
  102    102   
}
         103  +
impl PendingAggregationRequest {
         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  +
}
  103    114   
impl PendingAggregationRequest {
  104    115   
    /// Creates a new builder-style object to manufacture [`PendingAggregationRequest`](crate::types::PendingAggregationRequest).
  105    116   
    pub fn builder() -> crate::types::builders::PendingAggregationRequestBuilder {
  106    117   
        crate::types::builders::PendingAggregationRequestBuilder::default()
  107    118   
    }
  108    119   
}
  109    120   
  110    121   
/// A builder for [`PendingAggregationRequest`](crate::types::PendingAggregationRequest).
  111    122   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  112    123   
#[non_exhaustive]

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

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