AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_compliance_details_by_config_rule/_get_aggregate_compliance_details_by_config_rule_input.rs

@@ -38,38 +253,268 @@
   58     58   
    "GetAggregateComplianceDetailsByConfigRuleInput",
   59     59   
);
   60     60   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME: ::aws_smithy_schema::Schema =
   61     61   
    ::aws_smithy_schema::Schema::new_member(
   62     62   
        ::aws_smithy_schema::ShapeId::from_static(
   63     63   
            "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$ConfigurationAggregatorName",
   64     64   
            "com.amazonaws.configservice.synthetic",
   65     65   
            "GetAggregateComplianceDetailsByConfigRuleInput",
   66     66   
        ),
   67     67   
        ::aws_smithy_schema::ShapeType::String,
   68         -
        "configuration_aggregator_name",
          68  +
        "ConfigurationAggregatorName",
   69     69   
        0,
   70     70   
    );
   71     71   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIG_RULE_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$ConfigRuleName",
   74     74   
        "com.amazonaws.configservice.synthetic",
   75     75   
        "GetAggregateComplianceDetailsByConfigRuleInput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "config_rule_name",
          78  +
    "ConfigRuleName",
   79     79   
    1,
   80     80   
);
   81     81   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_ACCOUNT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$AccountId",
   84     84   
        "com.amazonaws.configservice.synthetic",
   85     85   
        "GetAggregateComplianceDetailsByConfigRuleInput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "account_id",
          88  +
    "AccountId",
   89     89   
    2,
   90     90   
);
   91     91   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_AWS_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$AwsRegion",
   94     94   
        "com.amazonaws.configservice.synthetic",
   95     95   
        "GetAggregateComplianceDetailsByConfigRuleInput",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "aws_region",
          98  +
    "AwsRegion",
   99     99   
    3,
  100    100   
);
  101    101   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_COMPLIANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$ComplianceType",
  104    104   
        "com.amazonaws.configservice.synthetic",
  105    105   
        "GetAggregateComplianceDetailsByConfigRuleInput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "compliance_type",
         108  +
    "ComplianceType",
  109    109   
    4,
  110    110   
);
  111    111   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_LIMIT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$Limit",
  114    114   
        "com.amazonaws.configservice.synthetic",
  115    115   
        "GetAggregateComplianceDetailsByConfigRuleInput",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::Integer,
  118         -
    "limit",
         118  +
    "Limit",
  119    119   
    5,
  120    120   
);
  121    121   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleInput$NextToken",
  124    124   
        "com.amazonaws.configservice.synthetic",
  125    125   
        "GetAggregateComplianceDetailsByConfigRuleInput",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "next_token",
         128  +
    "NextToken",
  129    129   
    6,
  130    130   
);
  131    131   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  132    132   
    GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_SCHEMA_ID,
  133    133   
    ::aws_smithy_schema::ShapeType::Structure,
  134    134   
    &[
  135    135   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME,
  136    136   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIG_RULE_NAME,
  137    137   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_ACCOUNT_ID,
  138    138   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_AWS_REGION,
  139    139   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_COMPLIANCE_TYPE,
  140    140   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_LIMIT,
  141    141   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_NEXT_TOKEN,
  142    142   
    ],
  143    143   
);
  144    144   
impl GetAggregateComplianceDetailsByConfigRuleInput {
  145    145   
    /// The schema for this shape.
  146    146   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_SCHEMA;
  147    147   
}
  148    148   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAggregateComplianceDetailsByConfigRuleInput {
  149    149   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  150    150   
    fn serialize_members(
  151    151   
        &self,
  152    152   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  153    153   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  154    154   
        if let Some(ref val) = self.configuration_aggregator_name {
  155    155   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIGURATION_AGGREGATOR_NAME, val)?;
  156    156   
        }
  157    157   
        if let Some(ref val) = self.config_rule_name {
  158    158   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_CONFIG_RULE_NAME, val)?;
  159    159   
        }
  160    160   
        if let Some(ref val) = self.account_id {
  161    161   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_ACCOUNT_ID, val)?;
  162    162   
        }
  163    163   
        if let Some(ref val) = self.aws_region {
  164    164   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_AWS_REGION, val)?;
  165    165   
        }
  166    166   
        if let Some(ref val) = self.compliance_type {
  167    167   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_COMPLIANCE_TYPE, val.as_str())?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.limit {
  170    170   
            ser.write_integer(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_LIMIT, *val)?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.next_token {
  173    173   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_MEMBER_NEXT_TOKEN, val)?;
  174    174   
        }
  175    175   
        Ok(())
  176    176   
    }
  177    177   
}
  178    178   
impl GetAggregateComplianceDetailsByConfigRuleInput {
  179    179   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  180         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  181         -
        deserializer: &mut D,
         180  +
    pub fn deserialize(
         181  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  182    182   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  183    183   
        #[allow(unused_variables, unused_mut)]
  184    184   
        let mut builder = Self::builder();
  185    185   
        #[allow(
  186    186   
            unused_variables,
  187    187   
            unreachable_code,
  188    188   
            clippy::single_match,
  189    189   
            clippy::match_single_binding,
  190    190   
            clippy::diverging_sub_expression
  191    191   
        )]
  192         -
        deserializer.read_struct(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_SCHEMA, (), |_, member, deser| {
         192  +
        deserializer.read_struct(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEINPUT_SCHEMA, &mut |member, deser| {
  193    193   
            match member.member_index() {
  194    194   
                Some(0) => {
  195    195   
                    builder.configuration_aggregator_name = Some(deser.read_string(member)?);
  196    196   
                }
  197    197   
                Some(1) => {
  198    198   
                    builder.config_rule_name = Some(deser.read_string(member)?);
  199    199   
                }
  200    200   
                Some(2) => {
  201    201   
                    builder.account_id = Some(deser.read_string(member)?);
  202    202   
                }
  203    203   
                Some(3) => {
  204    204   
                    builder.aws_region = Some(deser.read_string(member)?);
  205    205   
                }
  206    206   
                Some(4) => {
  207    207   
                    builder.compliance_type = Some(crate::types::ComplianceType::from(deser.read_string(member)?.as_str()));
  208    208   
                }
  209    209   
                Some(5) => {
  210    210   
                    builder.limit = Some(deser.read_integer(member)?);
  211    211   
                }
  212    212   
                Some(6) => {
  213    213   
                    builder.next_token = Some(deser.read_string(member)?);
  214    214   
                }
  215    215   
                _ => {}
  216    216   
            }
  217    217   
            Ok(())
  218    218   
        })?;
         219  +
        builder.configuration_aggregator_name = builder.configuration_aggregator_name.or(Some(String::new()));
         220  +
        builder.config_rule_name = builder.config_rule_name.or(Some(String::new()));
         221  +
        builder.account_id = builder.account_id.or(Some(String::new()));
         222  +
        builder.aws_region = builder.aws_region.or(Some(String::new()));
  219    223   
        builder
  220    224   
            .build()
  221    225   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  222    226   
    }
  223    227   
}
         228  +
impl GetAggregateComplianceDetailsByConfigRuleInput {
         229  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         230  +
    pub fn deserialize_with_response(
         231  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         232  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         233  +
        _status: u16,
         234  +
        _body: &[u8],
         235  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         236  +
        Self::deserialize(deserializer)
         237  +
    }
         238  +
}
  224    239   
impl GetAggregateComplianceDetailsByConfigRuleInput {
  225    240   
    /// Creates a new builder-style object to manufacture [`GetAggregateComplianceDetailsByConfigRuleInput`](crate::operation::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleInput).
  226    241   
    pub fn builder(
  227    242   
    ) -> crate::operation::get_aggregate_compliance_details_by_config_rule::builders::GetAggregateComplianceDetailsByConfigRuleInputBuilder {
  228    243   
        crate::operation::get_aggregate_compliance_details_by_config_rule::builders::GetAggregateComplianceDetailsByConfigRuleInputBuilder::default()
  229    244   
    }
  230    245   
}
  231    246   
  232    247   
/// A builder for [`GetAggregateComplianceDetailsByConfigRuleInput`](crate::operation::get_aggregate_compliance_details_by_config_rule::GetAggregateComplianceDetailsByConfigRuleInput).
  233    248   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_compliance_details_by_config_rule/_get_aggregate_compliance_details_by_config_rule_output.rs

@@ -7,7 +141,193 @@
   27     27   
    "GetAggregateComplianceDetailsByConfigRuleOutput",
   28     28   
);
   29     29   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_AGGREGATE_EVALUATION_RESULTS: ::aws_smithy_schema::Schema =
   30     30   
    ::aws_smithy_schema::Schema::new_member(
   31     31   
        ::aws_smithy_schema::ShapeId::from_static(
   32     32   
            "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleOutput$AggregateEvaluationResults",
   33     33   
            "com.amazonaws.configservice.synthetic",
   34     34   
            "GetAggregateComplianceDetailsByConfigRuleOutput",
   35     35   
        ),
   36     36   
        ::aws_smithy_schema::ShapeType::List,
   37         -
        "aggregate_evaluation_results",
          37  +
        "AggregateEvaluationResults",
   38     38   
        0,
   39     39   
    );
   40     40   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.configservice.synthetic#GetAggregateComplianceDetailsByConfigRuleOutput$NextToken",
   43     43   
        "com.amazonaws.configservice.synthetic",
   44     44   
        "GetAggregateComplianceDetailsByConfigRuleOutput",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::String,
   47         -
    "next_token",
          47  +
    "NextToken",
   48     48   
    1,
   49     49   
);
          50  +
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          51  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          52  +
    ::aws_smithy_schema::ShapeType::String,
          53  +
    "request_id",
          54  +
    2,
          55  +
)
          56  +
.with_http_header("x-amzn-requestid");
   50     57   
static GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   51     58   
    GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA_ID,
   52     59   
    ::aws_smithy_schema::ShapeType::Structure,
   53     60   
    &[
   54     61   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_AGGREGATE_EVALUATION_RESULTS,
   55     62   
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_NEXT_TOKEN,
          63  +
        &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER__REQUEST_ID,
   56     64   
    ],
   57     65   
);
   58     66   
impl GetAggregateComplianceDetailsByConfigRuleOutput {
   59     67   
    /// The schema for this shape.
   60     68   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA;
   61     69   
}
   62     70   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAggregateComplianceDetailsByConfigRuleOutput {
   63     71   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   64     72   
    fn serialize_members(
   65     73   
        &self,
   66     74   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   67     75   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   68     76   
        if let Some(ref val) = self.aggregate_evaluation_results {
   69     77   
            ser.write_list(
   70     78   
                &GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_AGGREGATE_EVALUATION_RESULTS,
   71     79   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   72     80   
                    for item in val {
   73     81   
                        ser.write_struct(crate::types::AggregateEvaluationResult::SCHEMA, item)?;
   74     82   
                    }
   75     83   
                    Ok(())
   76     84   
                },
   77     85   
            )?;
   78     86   
        }
   79     87   
        if let Some(ref val) = self.next_token {
   80     88   
            ser.write_string(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_MEMBER_NEXT_TOKEN, val)?;
   81     89   
        }
   82     90   
        Ok(())
   83     91   
    }
   84     92   
}
   85     93   
impl GetAggregateComplianceDetailsByConfigRuleOutput {
   86     94   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   87         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   88         -
        deserializer: &mut D,
          95  +
    pub fn deserialize(
          96  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   89     97   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   90     98   
        #[allow(unused_variables, unused_mut)]
   91     99   
        let mut builder = Self::builder();
   92    100   
        #[allow(
   93    101   
            unused_variables,
   94    102   
            unreachable_code,
   95    103   
            clippy::single_match,
   96    104   
            clippy::match_single_binding,
   97    105   
            clippy::diverging_sub_expression
   98    106   
        )]
   99         -
        deserializer.read_struct(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA, (), |_, member, deser| {
         107  +
        deserializer.read_struct(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA, &mut |member, deser| {
  100    108   
            match member.member_index() {
  101    109   
                Some(0) => {
  102    110   
                    builder.aggregate_evaluation_results = Some({
  103         -
                        let container = if let Some(cap) = deser.container_size() {
  104         -
                            Vec::with_capacity(cap)
  105         -
                        } else {
  106         -
                            Vec::new()
  107         -
                        };
  108         -
                        deser.read_list(member, container, |mut list, deser| {
  109         -
                            list.push(crate::types::AggregateEvaluationResult::deserialize(deser)?);
  110         -
                            Ok(list)
  111         -
                        })?
         111  +
                        let mut container = Vec::new();
         112  +
                        deser.read_list(member, &mut |deser| {
         113  +
                            container.push(crate::types::AggregateEvaluationResult::deserialize(deser)?);
         114  +
                            Ok(())
         115  +
                        })?;
         116  +
                        container
         117  +
                    });
         118  +
                }
         119  +
                Some(1) => {
         120  +
                    builder.next_token = Some(deser.read_string(member)?);
         121  +
                }
         122  +
                Some(2) => {
         123  +
                    builder._request_id = Some(deser.read_string(member)?);
         124  +
                }
         125  +
                _ => {}
         126  +
            }
         127  +
            Ok(())
         128  +
        })?;
         129  +
        Ok(builder.build())
         130  +
    }
         131  +
}
         132  +
impl GetAggregateComplianceDetailsByConfigRuleOutput {
         133  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         134  +
    /// Header-bound members are read directly from headers, avoiding runtime
         135  +
    /// member iteration overhead. Body members are read via the deserializer.
         136  +
    pub fn deserialize_with_response(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         138  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         139  +
        _status: u16,
         140  +
        _body: &[u8],
         141  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         142  +
        #[allow(unused_variables, unused_mut)]
         143  +
        let mut builder = Self::builder();
         144  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         145  +
            builder._request_id = Some(val.to_string());
         146  +
        }
         147  +
        #[allow(
         148  +
            unused_variables,
         149  +
            unreachable_code,
         150  +
            clippy::single_match,
         151  +
            clippy::match_single_binding,
         152  +
            clippy::diverging_sub_expression
         153  +
        )]
         154  +
        deserializer.read_struct(&GETAGGREGATECOMPLIANCEDETAILSBYCONFIGRULEOUTPUT_SCHEMA, &mut |member, deser| {
         155  +
            match member.member_index() {
         156  +
                Some(0) => {
         157  +
                    builder.aggregate_evaluation_results = Some({
         158  +
                        let mut container = Vec::new();
         159  +
                        deser.read_list(member, &mut |deser| {
         160  +
                            container.push(crate::types::AggregateEvaluationResult::deserialize(deser)?);
         161  +
                            Ok(())
         162  +
                        })?;
         163  +
                        container
  112    164   
                    });
  113    165   
                }
  114    166   
                Some(1) => {
  115    167   
                    builder.next_token = Some(deser.read_string(member)?);
  116    168   
                }
  117    169   
                _ => {}
  118    170   
            }
  119    171   
            Ok(())
  120    172   
        })?;
  121    173   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_config_rule_compliance_summary.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetAggregateConfigRuleComplianceSummary`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAggregateConfigRuleComplianceSummary;
    6      6   
impl GetAggregateConfigRuleComplianceSummary {
    7      7   
    /// Creates a new `GetAggregateConfigRuleComplianceSummary`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +259,321 @@
  144    150   
                crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetAggregateConfigRuleComplianceSummaryResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAggregateConfigRuleComplianceSummaryResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_get_aggregate_config_rule_compliance_summary::de_get_aggregate_config_rule_compliance_summary_http_error(
  166         -
                status, headers, body,
  167         -
            )
  168         -
        } else {
  169         -
            crate::protocol_serde::shape_get_aggregate_config_rule_compliance_summary::de_get_aggregate_config_rule_compliance_summary_http_response(
  170         -
                status, headers, body,
  171         -
            )
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                ::std::option::Option::Some(code) => code,
         180  +
                ::std::option::Option::None => {
         181  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         182  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         183  +
                            crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::unhandled(
         184  +
                                generic,
         185  +
                            ),
         186  +
                        ),
         187  +
                    ))
         188  +
                }
         189  +
            };
         190  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         191  +
            let protocol = _cfg
         192  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         193  +
                .expect("a SharedClientProtocol is required");
         194  +
            let err = match error_code {
         195  +
"InvalidLimitException" => crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::InvalidLimitException({
         196  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidLimitException::SCHEMA, _cfg)
         197  +
                        .and_then(|mut deser| crate::types::error::InvalidLimitException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         198  +
                    {
         199  +
                        ::std::result::Result::Ok(val) => val,
         200  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
  172    201   
                    };
  173         -
        crate::protocol_serde::type_erase_result(parse_result)
         202  +
                    tmp.meta = generic;
         203  +
if tmp.message.is_none() {
         204  +
                                tmp.message = _error_message;
         205  +
                            }
         206  +
tmp
         207  +
}),
         208  +
"InvalidNextTokenException" => crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::InvalidNextTokenException({
         209  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
         210  +
                        .and_then(|mut deser| crate::types::error::InvalidNextTokenException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         211  +
                    {
         212  +
                        ::std::result::Result::Ok(val) => val,
         213  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         214  +
                    };
         215  +
                    tmp.meta = generic;
         216  +
if tmp.message.is_none() {
         217  +
                                tmp.message = _error_message;
         218  +
                            }
         219  +
tmp
         220  +
}),
         221  +
"NoSuchConfigurationAggregatorException" => crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::NoSuchConfigurationAggregatorException({
         222  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::NoSuchConfigurationAggregatorException::SCHEMA, _cfg)
         223  +
                        .and_then(|mut deser| crate::types::error::NoSuchConfigurationAggregatorException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         224  +
                    {
         225  +
                        ::std::result::Result::Ok(val) => val,
         226  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         227  +
                    };
         228  +
                    tmp.meta = generic;
         229  +
if tmp.message.is_none() {
         230  +
                                tmp.message = _error_message;
         231  +
                            }
         232  +
tmp
         233  +
}),
         234  +
"ValidationException" => crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::ValidationException({
         235  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         236  +
                        .and_then(|mut deser| crate::types::error::ValidationException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         237  +
                    {
         238  +
                        ::std::result::Result::Ok(val) => val,
         239  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         240  +
                    };
         241  +
                    tmp.meta = generic;
         242  +
if tmp.message.is_none() {
         243  +
                                tmp.message = _error_message;
         244  +
                            }
         245  +
tmp
         246  +
}),
         247  +
_ => crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryError::generic(generic)
         248  +
};
         249  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         250  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         251  +
            ))
         252  +
        } else {
         253  +
            let protocol = _cfg
         254  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         255  +
                .expect("a SharedClientProtocol is required");
         256  +
            let mut deser = protocol
         257  +
                .deserialize_response(response, GetAggregateConfigRuleComplianceSummary::OUTPUT_SCHEMA, _cfg)
         258  +
                .map_err(|e| {
         259  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         260  +
                })?;
         261  +
            let body = response.body().bytes().expect("body loaded");
         262  +
            let output = crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryOutput::deserialize_with_response(
         263  +
                    &mut *deser,
         264  +
                    response.headers(),
         265  +
                    response.status().into(),
         266  +
                    body,
         267  +
                ).map_err(|e| ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e)))?;
         268  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         269  +
        }
  174    270   
    }
  175    271   
}
  176    272   
#[derive(Debug)]
  177    273   
struct GetAggregateConfigRuleComplianceSummaryRequestSerializer;
  178    274   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAggregateConfigRuleComplianceSummaryRequestSerializer {
  179    275   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  180    276   
    fn serialize_input(
  181    277   
        &self,
  182    278   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  183    279   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  184    280   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  185    281   
        let input = input
  186    282   
            .downcast::<crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryInput>()
  187    283   
            .expect("correct type");
  188         -
        let _header_serialization_settings = _cfg
  189         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  190         -
            .cloned()
  191         -
            .unwrap_or_default();
  192         -
        let mut request_builder = {
  193         -
            #[allow(clippy::uninlined_format_args)]
  194         -
            fn uri_base(
  195         -
                _input: &crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryInput,
  196         -
                output: &mut ::std::string::String,
  197         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198         -
                use ::std::fmt::Write as _;
  199         -
                ::std::write!(output, "/").expect("formatting should succeed");
  200         -
                ::std::result::Result::Ok(())
  201         -
            }
  202         -
            #[allow(clippy::unnecessary_wraps)]
  203         -
            fn update_http_builder(
  204         -
                input: &crate::operation::get_aggregate_config_rule_compliance_summary::GetAggregateConfigRuleComplianceSummaryInput,
  205         -
                builder: ::http_1x::request::Builder,
  206         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207         -
                let mut uri = ::std::string::String::new();
  208         -
                uri_base(input, &mut uri)?;
  209         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210         -
            }
  211         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  213         -
            builder = _header_serialization_settings.set_default_header(
  214         -
                builder,
  215         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  216         -
                "StarlingDoveService.GetAggregateConfigRuleComplianceSummary",
  217         -
            );
  218         -
            builder
  219         -
        };
  220         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  221         -
            crate::protocol_serde::shape_get_aggregate_config_rule_compliance_summary::ser_get_aggregate_config_rule_compliance_summary_input(
  222         -
                &input,
  223         -
            )?,
  224         -
        );
  225         -
        if let Some(content_length) = body.content_length() {
  226         -
            let content_length = content_length.to_string();
  227         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  228         -
        }
  229         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         284  +
        let protocol = _cfg
         285  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         286  +
            .expect("a SharedClientProtocol is required");
         287  +
        let mut request = protocol
         288  +
            .serialize_request(&input, GetAggregateConfigRuleComplianceSummary::INPUT_SCHEMA, "", _cfg)
         289  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         290  +
         291  +
        return ::std::result::Result::Ok(request);
  230    292   
    }
  231    293   
}
  232    294   
#[derive(Debug)]
  233    295   
struct GetAggregateConfigRuleComplianceSummaryEndpointParamsInterceptor;
  234    296   
  235    297   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAggregateConfigRuleComplianceSummaryEndpointParamsInterceptor {
  236    298   
    fn name(&self) -> &'static str {
  237    299   
        "GetAggregateConfigRuleComplianceSummaryEndpointParamsInterceptor"
  238    300   
    }
  239    301

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_config_rule_compliance_summary/_get_aggregate_config_rule_compliance_summary_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_config_rule_compliance_summary/_get_aggregate_config_rule_compliance_summary_output.rs

@@ -12,12 +164,219 @@
   32     32   
    "com.amazonaws.configservice.synthetic",
   33     33   
    "GetAggregateConfigRuleComplianceSummaryOutput",
   34     34   
);
   35     35   
static GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.configservice.synthetic#GetAggregateConfigRuleComplianceSummaryOutput$GroupByKey",
   38     38   
        "com.amazonaws.configservice.synthetic",
   39     39   
        "GetAggregateConfigRuleComplianceSummaryOutput",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "group_by_key",
          42  +
    "GroupByKey",
   43     43   
    0,
   44     44   
);
   45     45   
static GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_COMPLIANCE_COUNTS: ::aws_smithy_schema::Schema =
   46     46   
    ::aws_smithy_schema::Schema::new_member(
   47     47   
        ::aws_smithy_schema::ShapeId::from_static(
   48     48   
            "com.amazonaws.configservice.synthetic#GetAggregateConfigRuleComplianceSummaryOutput$AggregateComplianceCounts",
   49     49   
            "com.amazonaws.configservice.synthetic",
   50     50   
            "GetAggregateConfigRuleComplianceSummaryOutput",
   51     51   
        ),
   52     52   
        ::aws_smithy_schema::ShapeType::List,
   53         -
        "aggregate_compliance_counts",
          53  +
        "AggregateComplianceCounts",
   54     54   
        1,
   55     55   
    );
   56     56   
static GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.configservice.synthetic#GetAggregateConfigRuleComplianceSummaryOutput$NextToken",
   59     59   
        "com.amazonaws.configservice.synthetic",
   60     60   
        "GetAggregateConfigRuleComplianceSummaryOutput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "next_token",
          63  +
    "NextToken",
   64     64   
    2,
   65     65   
);
          66  +
static GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          67  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          68  +
    ::aws_smithy_schema::ShapeType::String,
          69  +
    "request_id",
          70  +
    3,
          71  +
)
          72  +
.with_http_header("x-amzn-requestid");
   66     73   
static GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   67     74   
    GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA_ID,
   68     75   
    ::aws_smithy_schema::ShapeType::Structure,
   69     76   
    &[
   70     77   
        &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY,
   71     78   
        &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_COMPLIANCE_COUNTS,
   72     79   
        &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN,
          80  +
        &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER__REQUEST_ID,
   73     81   
    ],
   74     82   
);
   75     83   
impl GetAggregateConfigRuleComplianceSummaryOutput {
   76     84   
    /// The schema for this shape.
   77     85   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA;
   78     86   
}
   79     87   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAggregateConfigRuleComplianceSummaryOutput {
   80     88   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   81     89   
    fn serialize_members(
   82     90   
        &self,
   83     91   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   84     92   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   85     93   
        if let Some(ref val) = self.group_by_key {
   86     94   
            ser.write_string(&GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY, val)?;
   87     95   
        }
   88     96   
        if let Some(ref val) = self.aggregate_compliance_counts {
   89     97   
            ser.write_list(
   90     98   
                &GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_COMPLIANCE_COUNTS,
   91     99   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   92    100   
                    for item in val {
   93    101   
                        ser.write_struct(crate::types::AggregateComplianceCount::SCHEMA, item)?;
   94    102   
                    }
   95    103   
                    Ok(())
   96    104   
                },
   97    105   
            )?;
   98    106   
        }
   99    107   
        if let Some(ref val) = self.next_token {
  100    108   
            ser.write_string(&GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN, val)?;
  101    109   
        }
  102    110   
        Ok(())
  103    111   
    }
  104    112   
}
  105    113   
impl GetAggregateConfigRuleComplianceSummaryOutput {
  106    114   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  107         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  108         -
        deserializer: &mut D,
         115  +
    pub fn deserialize(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         118  +
        #[allow(unused_variables, unused_mut)]
         119  +
        let mut builder = Self::builder();
         120  +
        #[allow(
         121  +
            unused_variables,
         122  +
            unreachable_code,
         123  +
            clippy::single_match,
         124  +
            clippy::match_single_binding,
         125  +
            clippy::diverging_sub_expression
         126  +
        )]
         127  +
        deserializer.read_struct(&GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
         128  +
            match member.member_index() {
         129  +
                Some(0) => {
         130  +
                    builder.group_by_key = Some(deser.read_string(member)?);
         131  +
                }
         132  +
                Some(1) => {
         133  +
                    builder.aggregate_compliance_counts = Some({
         134  +
                        let mut container = Vec::new();
         135  +
                        deser.read_list(member, &mut |deser| {
         136  +
                            container.push(crate::types::AggregateComplianceCount::deserialize(deser)?);
         137  +
                            Ok(())
         138  +
                        })?;
         139  +
                        container
         140  +
                    });
         141  +
                }
         142  +
                Some(2) => {
         143  +
                    builder.next_token = Some(deser.read_string(member)?);
         144  +
                }
         145  +
                Some(3) => {
         146  +
                    builder._request_id = Some(deser.read_string(member)?);
         147  +
                }
         148  +
                _ => {}
         149  +
            }
         150  +
            Ok(())
         151  +
        })?;
         152  +
        Ok(builder.build())
         153  +
    }
         154  +
}
         155  +
impl GetAggregateConfigRuleComplianceSummaryOutput {
         156  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         157  +
    /// Header-bound members are read directly from headers, avoiding runtime
         158  +
    /// member iteration overhead. Body members are read via the deserializer.
         159  +
    pub fn deserialize_with_response(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         161  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         162  +
        _status: u16,
         163  +
        _body: &[u8],
  109    164   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  110    165   
        #[allow(unused_variables, unused_mut)]
  111    166   
        let mut builder = Self::builder();
         167  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         168  +
            builder._request_id = Some(val.to_string());
         169  +
        }
  112    170   
        #[allow(
  113    171   
            unused_variables,
  114    172   
            unreachable_code,
  115    173   
            clippy::single_match,
  116    174   
            clippy::match_single_binding,
  117    175   
            clippy::diverging_sub_expression
  118    176   
        )]
  119         -
        deserializer.read_struct(&GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA, (), |_, member, deser| {
         177  +
        deserializer.read_struct(&GETAGGREGATECONFIGRULECOMPLIANCESUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
  120    178   
            match member.member_index() {
  121    179   
                Some(0) => {
  122    180   
                    builder.group_by_key = Some(deser.read_string(member)?);
  123    181   
                }
  124    182   
                Some(1) => {
  125    183   
                    builder.aggregate_compliance_counts = Some({
  126         -
                        let container = if let Some(cap) = deser.container_size() {
  127         -
                            Vec::with_capacity(cap)
  128         -
                        } else {
  129         -
                            Vec::new()
  130         -
                        };
  131         -
                        deser.read_list(member, container, |mut list, deser| {
  132         -
                            list.push(crate::types::AggregateComplianceCount::deserialize(deser)?);
  133         -
                            Ok(list)
  134         -
                        })?
         184  +
                        let mut container = Vec::new();
         185  +
                        deser.read_list(member, &mut |deser| {
         186  +
                            container.push(crate::types::AggregateComplianceCount::deserialize(deser)?);
         187  +
                            Ok(())
         188  +
                        })?;
         189  +
                        container
  135    190   
                    });
  136    191   
                }
  137    192   
                Some(2) => {
  138    193   
                    builder.next_token = Some(deser.read_string(member)?);
  139    194   
                }
  140    195   
                _ => {}
  141    196   
            }
  142    197   
            Ok(())
  143    198   
        })?;
  144    199   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_conformance_pack_compliance_summary.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetAggregateConformancePackComplianceSummary`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAggregateConformancePackComplianceSummary;
    6      6   
impl GetAggregateConformancePackComplianceSummary {
    7      7   
    /// Creates a new `GetAggregateConformancePackComplianceSummary`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +251,313 @@
  144    150   
                    crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError,
  145    151   
                >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetAggregateConformancePackComplianceSummaryResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAggregateConformancePackComplianceSummaryResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_get_aggregate_conformance_pack_compliance_summary::de_get_aggregate_conformance_pack_compliance_summary_http_error(status, headers, body)
  166         -
        } else {
  167         -
            crate::protocol_serde::shape_get_aggregate_conformance_pack_compliance_summary::de_get_aggregate_conformance_pack_compliance_summary_http_response(status, headers, body)
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                    ::std::option::Option::Some(code) => code,
         180  +
                    ::std::option::Option::None => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::unhandled(generic)))),
         181  +
                };
         182  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         183  +
            let protocol = _cfg
         184  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         185  +
                .expect("a SharedClientProtocol is required");
         186  +
            let err = match error_code {
         187  +
"InvalidLimitException" => crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::InvalidLimitException({
         188  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidLimitException::SCHEMA, _cfg)
         189  +
                        .and_then(|mut deser| crate::types::error::InvalidLimitException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         190  +
                    {
         191  +
                        ::std::result::Result::Ok(val) => val,
         192  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         193  +
                    };
         194  +
                    tmp.meta = generic;
         195  +
if tmp.message.is_none() {
         196  +
                                tmp.message = _error_message;
         197  +
                            }
         198  +
tmp
         199  +
}),
         200  +
"InvalidNextTokenException" => crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::InvalidNextTokenException({
         201  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
         202  +
                        .and_then(|mut deser| crate::types::error::InvalidNextTokenException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         203  +
                    {
         204  +
                        ::std::result::Result::Ok(val) => val,
         205  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         206  +
                    };
         207  +
                    tmp.meta = generic;
         208  +
if tmp.message.is_none() {
         209  +
                                tmp.message = _error_message;
         210  +
                            }
         211  +
tmp
         212  +
}),
         213  +
"NoSuchConfigurationAggregatorException" => crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::NoSuchConfigurationAggregatorException({
         214  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::NoSuchConfigurationAggregatorException::SCHEMA, _cfg)
         215  +
                        .and_then(|mut deser| crate::types::error::NoSuchConfigurationAggregatorException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         216  +
                    {
         217  +
                        ::std::result::Result::Ok(val) => val,
         218  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         219  +
                    };
         220  +
                    tmp.meta = generic;
         221  +
if tmp.message.is_none() {
         222  +
                                tmp.message = _error_message;
         223  +
                            }
         224  +
tmp
         225  +
}),
         226  +
"ValidationException" => crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::ValidationException({
         227  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         228  +
                        .and_then(|mut deser| crate::types::error::ValidationException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         229  +
                    {
         230  +
                        ::std::result::Result::Ok(val) => val,
         231  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
  168    232   
                    };
  169         -
        crate::protocol_serde::type_erase_result(parse_result)
         233  +
                    tmp.meta = generic;
         234  +
if tmp.message.is_none() {
         235  +
                                tmp.message = _error_message;
         236  +
                            }
         237  +
tmp
         238  +
}),
         239  +
_ => crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryError::generic(generic)
         240  +
};
         241  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         242  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         243  +
            ))
         244  +
        } else {
         245  +
            let protocol = _cfg
         246  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         247  +
                .expect("a SharedClientProtocol is required");
         248  +
            let mut deser = protocol
         249  +
                .deserialize_response(response, GetAggregateConformancePackComplianceSummary::OUTPUT_SCHEMA, _cfg)
         250  +
                .map_err(|e| {
         251  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         252  +
                })?;
         253  +
            let body = response.body().bytes().expect("body loaded");
         254  +
            let output = crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryOutput::deserialize_with_response(
         255  +
                    &mut *deser,
         256  +
                    response.headers(),
         257  +
                    response.status().into(),
         258  +
                    body,
         259  +
                ).map_err(|e| ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e)))?;
         260  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         261  +
        }
  170    262   
    }
  171    263   
}
  172    264   
#[derive(Debug)]
  173    265   
struct GetAggregateConformancePackComplianceSummaryRequestSerializer;
  174    266   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAggregateConformancePackComplianceSummaryRequestSerializer {
  175    267   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  176    268   
    fn serialize_input(
  177    269   
        &self,
  178    270   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  179    271   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  180    272   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  181    273   
        let input = input
  182    274   
            .downcast::<crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryInput>()
  183    275   
            .expect("correct type");
  184         -
        let _header_serialization_settings = _cfg
  185         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  186         -
            .cloned()
  187         -
            .unwrap_or_default();
  188         -
        let mut request_builder = {
  189         -
            #[allow(clippy::uninlined_format_args)]
  190         -
            fn uri_base(
  191         -
                _input: &crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryInput,
  192         -
                output: &mut ::std::string::String,
  193         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194         -
                use ::std::fmt::Write as _;
  195         -
                ::std::write!(output, "/").expect("formatting should succeed");
  196         -
                ::std::result::Result::Ok(())
  197         -
            }
  198         -
            #[allow(clippy::unnecessary_wraps)]
  199         -
            fn update_http_builder(
  200         -
                input: &crate::operation::get_aggregate_conformance_pack_compliance_summary::GetAggregateConformancePackComplianceSummaryInput,
  201         -
                builder: ::http_1x::request::Builder,
  202         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  203         -
                let mut uri = ::std::string::String::new();
  204         -
                uri_base(input, &mut uri)?;
  205         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  206         -
            }
  207         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  208         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  209         -
            builder = _header_serialization_settings.set_default_header(
  210         -
                builder,
  211         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212         -
                "StarlingDoveService.GetAggregateConformancePackComplianceSummary",
  213         -
            );
  214         -
            builder
  215         -
        };
  216         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_get_aggregate_conformance_pack_compliance_summary::ser_get_aggregate_conformance_pack_compliance_summary_input(&input)?);
  217         -
        if let Some(content_length) = body.content_length() {
  218         -
            let content_length = content_length.to_string();
  219         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  220         -
        }
  221         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         276  +
        let protocol = _cfg
         277  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         278  +
            .expect("a SharedClientProtocol is required");
         279  +
        let mut request = protocol
         280  +
            .serialize_request(&input, GetAggregateConformancePackComplianceSummary::INPUT_SCHEMA, "", _cfg)
         281  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         282  +
         283  +
        return ::std::result::Result::Ok(request);
  222    284   
    }
  223    285   
}
  224    286   
#[derive(Debug)]
  225    287   
struct GetAggregateConformancePackComplianceSummaryEndpointParamsInterceptor;
  226    288   
  227    289   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAggregateConformancePackComplianceSummaryEndpointParamsInterceptor {
  228    290   
    fn name(&self) -> &'static str {
  229    291   
        "GetAggregateConformancePackComplianceSummaryEndpointParamsInterceptor"
  230    292   
    }
  231    293

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_conformance_pack_compliance_summary/_get_aggregate_conformance_pack_compliance_summary_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_conformance_pack_compliance_summary/_get_aggregate_conformance_pack_compliance_summary_output.rs

@@ -14,14 +162,217 @@
   34     34   
    "GetAggregateConformancePackComplianceSummaryOutput",
   35     35   
);
   36     36   
static GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_CONFORMANCE_PACK_COMPLIANCE_SUMMARIES: ::aws_smithy_schema::Schema =
   37     37   
    ::aws_smithy_schema::Schema::new_member(
   38     38   
        ::aws_smithy_schema::ShapeId::from_static(
   39     39   
            "com.amazonaws.configservice.synthetic#GetAggregateConformancePackComplianceSummaryOutput$AggregateConformancePackComplianceSummaries",
   40     40   
            "com.amazonaws.configservice.synthetic",
   41     41   
            "GetAggregateConformancePackComplianceSummaryOutput",
   42     42   
        ),
   43     43   
        ::aws_smithy_schema::ShapeType::List,
   44         -
        "aggregate_conformance_pack_compliance_summaries",
          44  +
        "AggregateConformancePackComplianceSummaries",
   45     45   
        0,
   46     46   
    );
   47     47   
static GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.configservice.synthetic#GetAggregateConformancePackComplianceSummaryOutput$GroupByKey",
   50     50   
        "com.amazonaws.configservice.synthetic",
   51     51   
        "GetAggregateConformancePackComplianceSummaryOutput",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "group_by_key",
          54  +
    "GroupByKey",
   55     55   
    1,
   56     56   
);
   57     57   
static GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.configservice.synthetic#GetAggregateConformancePackComplianceSummaryOutput$NextToken",
   60     60   
        "com.amazonaws.configservice.synthetic",
   61     61   
        "GetAggregateConformancePackComplianceSummaryOutput",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "next_token",
          64  +
    "NextToken",
   65     65   
    2,
   66     66   
);
          67  +
static GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          68  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          69  +
    ::aws_smithy_schema::ShapeType::String,
          70  +
    "request_id",
          71  +
    3,
          72  +
)
          73  +
.with_http_header("x-amzn-requestid");
   67     74   
static GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   68     75   
    GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA_ID,
   69     76   
    ::aws_smithy_schema::ShapeType::Structure,
   70     77   
    &[
   71     78   
        &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_CONFORMANCE_PACK_COMPLIANCE_SUMMARIES,
   72     79   
        &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY,
   73     80   
        &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN,
          81  +
        &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER__REQUEST_ID,
   74     82   
    ],
   75     83   
);
   76     84   
impl GetAggregateConformancePackComplianceSummaryOutput {
   77     85   
    /// The schema for this shape.
   78     86   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA;
   79     87   
}
   80     88   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAggregateConformancePackComplianceSummaryOutput {
   81     89   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   82     90   
    fn serialize_members(
   83     91   
        &self,
   84     92   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   85     93   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   86     94   
        if let Some(ref val) = self.aggregate_conformance_pack_compliance_summaries {
   87     95   
            ser.write_list(
   88     96   
                &GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_AGGREGATE_CONFORMANCE_PACK_COMPLIANCE_SUMMARIES,
   89     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   90     98   
                    for item in val {
   91     99   
                        ser.write_struct(crate::types::AggregateConformancePackComplianceSummary::SCHEMA, item)?;
   92    100   
                    }
   93    101   
                    Ok(())
   94    102   
                },
   95    103   
            )?;
   96    104   
        }
   97    105   
        if let Some(ref val) = self.group_by_key {
   98    106   
            ser.write_string(&GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_GROUP_BY_KEY, val)?;
   99    107   
        }
  100    108   
        if let Some(ref val) = self.next_token {
  101    109   
            ser.write_string(&GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_MEMBER_NEXT_TOKEN, val)?;
  102    110   
        }
  103    111   
        Ok(())
  104    112   
    }
  105    113   
}
  106    114   
impl GetAggregateConformancePackComplianceSummaryOutput {
  107    115   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  108         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  109         -
        deserializer: &mut D,
         116  +
    pub fn deserialize(
         117  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         118  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         119  +
        #[allow(unused_variables, unused_mut)]
         120  +
        let mut builder = Self::builder();
         121  +
        #[allow(
         122  +
            unused_variables,
         123  +
            unreachable_code,
         124  +
            clippy::single_match,
         125  +
            clippy::match_single_binding,
         126  +
            clippy::diverging_sub_expression
         127  +
        )]
         128  +
        deserializer.read_struct(&GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
         129  +
            match member.member_index() {
         130  +
                Some(0) => {
         131  +
                    builder.aggregate_conformance_pack_compliance_summaries = Some({
         132  +
                        let mut container = Vec::new();
         133  +
                        deser.read_list(member, &mut |deser| {
         134  +
                            container.push(crate::types::AggregateConformancePackComplianceSummary::deserialize(deser)?);
         135  +
                            Ok(())
         136  +
                        })?;
         137  +
                        container
         138  +
                    });
         139  +
                }
         140  +
                Some(1) => {
         141  +
                    builder.group_by_key = Some(deser.read_string(member)?);
         142  +
                }
         143  +
                Some(2) => {
         144  +
                    builder.next_token = Some(deser.read_string(member)?);
         145  +
                }
         146  +
                Some(3) => {
         147  +
                    builder._request_id = Some(deser.read_string(member)?);
         148  +
                }
         149  +
                _ => {}
         150  +
            }
         151  +
            Ok(())
         152  +
        })?;
         153  +
        Ok(builder.build())
         154  +
    }
         155  +
}
         156  +
impl GetAggregateConformancePackComplianceSummaryOutput {
         157  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         158  +
    /// Header-bound members are read directly from headers, avoiding runtime
         159  +
    /// member iteration overhead. Body members are read via the deserializer.
         160  +
    pub fn deserialize_with_response(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         162  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         163  +
        _status: u16,
         164  +
        _body: &[u8],
  110    165   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  111    166   
        #[allow(unused_variables, unused_mut)]
  112    167   
        let mut builder = Self::builder();
         168  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         169  +
            builder._request_id = Some(val.to_string());
         170  +
        }
  113    171   
        #[allow(
  114    172   
            unused_variables,
  115    173   
            unreachable_code,
  116    174   
            clippy::single_match,
  117    175   
            clippy::match_single_binding,
  118    176   
            clippy::diverging_sub_expression
  119    177   
        )]
  120         -
        deserializer.read_struct(&GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA, (), |_, member, deser| {
         178  +
        deserializer.read_struct(&GETAGGREGATECONFORMANCEPACKCOMPLIANCESUMMARYOUTPUT_SCHEMA, &mut |member, deser| {
  121    179   
            match member.member_index() {
  122    180   
                Some(0) => {
  123    181   
                    builder.aggregate_conformance_pack_compliance_summaries = Some({
  124         -
                        let container = if let Some(cap) = deser.container_size() {
  125         -
                            Vec::with_capacity(cap)
  126         -
                        } else {
  127         -
                            Vec::new()
  128         -
                        };
  129         -
                        deser.read_list(member, container, |mut list, deser| {
  130         -
                            list.push(crate::types::AggregateConformancePackComplianceSummary::deserialize(deser)?);
  131         -
                            Ok(list)
  132         -
                        })?
         182  +
                        let mut container = Vec::new();
         183  +
                        deser.read_list(member, &mut |deser| {
         184  +
                            container.push(crate::types::AggregateConformancePackComplianceSummary::deserialize(deser)?);
         185  +
                            Ok(())
         186  +
                        })?;
         187  +
                        container
  133    188   
                    });
  134    189   
                }
  135    190   
                Some(1) => {
  136    191   
                    builder.group_by_key = Some(deser.read_string(member)?);
  137    192   
                }
  138    193   
                Some(2) => {
  139    194   
                    builder.next_token = Some(deser.read_string(member)?);
  140    195   
                }
  141    196   
                _ => {}
  142    197   
            }

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_discovered_resource_counts.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetAggregateDiscoveredResourceCounts`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAggregateDiscoveredResourceCounts;
    6      6   
impl GetAggregateDiscoveredResourceCounts {
    7      7   
    /// Creates a new `GetAggregateDiscoveredResourceCounts`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +257,323 @@
  144    150   
                crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetAggregateDiscoveredResourceCountsResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAggregateDiscoveredResourceCountsResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_get_aggregate_discovered_resource_counts::de_get_aggregate_discovered_resource_counts_http_error(
  166         -
                status, headers, body,
  167         -
            )
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                ::std::option::Option::Some(code) => code,
         180  +
                ::std::option::Option::None => {
         181  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         182  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         183  +
                            crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::unhandled(generic),
         184  +
                        ),
         185  +
                    ))
         186  +
                }
         187  +
            };
         188  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         189  +
            let protocol = _cfg
         190  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         191  +
                .expect("a SharedClientProtocol is required");
         192  +
            let err = match error_code {
         193  +
"InvalidLimitException" => crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::InvalidLimitException({
         194  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidLimitException::SCHEMA, _cfg)
         195  +
                        .and_then(|mut deser| crate::types::error::InvalidLimitException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         196  +
                    {
         197  +
                        ::std::result::Result::Ok(val) => val,
         198  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         199  +
                    };
         200  +
                    tmp.meta = generic;
         201  +
if tmp.message.is_none() {
         202  +
                                tmp.message = _error_message;
         203  +
                            }
         204  +
tmp
         205  +
}),
         206  +
"InvalidNextTokenException" => crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::InvalidNextTokenException({
         207  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidNextTokenException::SCHEMA, _cfg)
         208  +
                        .and_then(|mut deser| crate::types::error::InvalidNextTokenException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         209  +
                    {
         210  +
                        ::std::result::Result::Ok(val) => val,
         211  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         212  +
                    };
         213  +
                    tmp.meta = generic;
         214  +
if tmp.message.is_none() {
         215  +
                                tmp.message = _error_message;
         216  +
                            }
         217  +
tmp
         218  +
}),
         219  +
"NoSuchConfigurationAggregatorException" => crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::NoSuchConfigurationAggregatorException({
         220  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::NoSuchConfigurationAggregatorException::SCHEMA, _cfg)
         221  +
                        .and_then(|mut deser| crate::types::error::NoSuchConfigurationAggregatorException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         222  +
                    {
         223  +
                        ::std::result::Result::Ok(val) => val,
         224  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         225  +
                    };
         226  +
                    tmp.meta = generic;
         227  +
if tmp.message.is_none() {
         228  +
                                tmp.message = _error_message;
         229  +
                            }
         230  +
tmp
         231  +
}),
         232  +
"ValidationException" => crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::ValidationException({
         233  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         234  +
                        .and_then(|mut deser| crate::types::error::ValidationException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         235  +
                    {
         236  +
                        ::std::result::Result::Ok(val) => val,
         237  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         238  +
                    };
         239  +
                    tmp.meta = generic;
         240  +
if tmp.message.is_none() {
         241  +
                                tmp.message = _error_message;
         242  +
                            }
         243  +
tmp
         244  +
}),
         245  +
_ => crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsError::generic(generic)
         246  +
};
         247  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         248  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         249  +
            ))
  168    250   
        } else {
  169         -
            crate::protocol_serde::shape_get_aggregate_discovered_resource_counts::de_get_aggregate_discovered_resource_counts_http_response(
  170         -
                status, headers, body,
         251  +
            let protocol = _cfg
         252  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         253  +
                .expect("a SharedClientProtocol is required");
         254  +
            let mut deser = protocol
         255  +
                .deserialize_response(response, GetAggregateDiscoveredResourceCounts::OUTPUT_SCHEMA, _cfg)
         256  +
                .map_err(|e| {
         257  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         258  +
                })?;
         259  +
            let body = response.body().bytes().expect("body loaded");
         260  +
            let output =
         261  +
                crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsOutput::deserialize_with_response(
         262  +
                    &mut *deser,
         263  +
                    response.headers(),
         264  +
                    response.status().into(),
         265  +
                    body,
  171    266   
                )
  172         -
        };
  173         -
        crate::protocol_serde::type_erase_result(parse_result)
         267  +
                .map_err(|e| {
         268  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         269  +
                })?;
         270  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         271  +
        }
  174    272   
    }
  175    273   
}
  176    274   
#[derive(Debug)]
  177    275   
struct GetAggregateDiscoveredResourceCountsRequestSerializer;
  178    276   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAggregateDiscoveredResourceCountsRequestSerializer {
  179    277   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  180    278   
    fn serialize_input(
  181    279   
        &self,
  182    280   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  183    281   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  184    282   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  185    283   
        let input = input
  186    284   
            .downcast::<crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsInput>()
  187    285   
            .expect("correct type");
  188         -
        let _header_serialization_settings = _cfg
  189         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  190         -
            .cloned()
  191         -
            .unwrap_or_default();
  192         -
        let mut request_builder = {
  193         -
            #[allow(clippy::uninlined_format_args)]
  194         -
            fn uri_base(
  195         -
                _input: &crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsInput,
  196         -
                output: &mut ::std::string::String,
  197         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198         -
                use ::std::fmt::Write as _;
  199         -
                ::std::write!(output, "/").expect("formatting should succeed");
  200         -
                ::std::result::Result::Ok(())
  201         -
            }
  202         -
            #[allow(clippy::unnecessary_wraps)]
  203         -
            fn update_http_builder(
  204         -
                input: &crate::operation::get_aggregate_discovered_resource_counts::GetAggregateDiscoveredResourceCountsInput,
  205         -
                builder: ::http_1x::request::Builder,
  206         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207         -
                let mut uri = ::std::string::String::new();
  208         -
                uri_base(input, &mut uri)?;
  209         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210         -
            }
  211         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  213         -
            builder = _header_serialization_settings.set_default_header(
  214         -
                builder,
  215         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  216         -
                "StarlingDoveService.GetAggregateDiscoveredResourceCounts",
  217         -
            );
  218         -
            builder
  219         -
        };
  220         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  221         -
            crate::protocol_serde::shape_get_aggregate_discovered_resource_counts::ser_get_aggregate_discovered_resource_counts_input(&input)?,
  222         -
        );
  223         -
        if let Some(content_length) = body.content_length() {
  224         -
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226         -
        }
  227         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         286  +
        let protocol = _cfg
         287  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         288  +
            .expect("a SharedClientProtocol is required");
         289  +
        let mut request = protocol
         290  +
            .serialize_request(&input, GetAggregateDiscoveredResourceCounts::INPUT_SCHEMA, "", _cfg)
         291  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         292  +
         293  +
        return ::std::result::Result::Ok(request);
  228    294   
    }
  229    295   
}
  230    296   
#[derive(Debug)]
  231    297   
struct GetAggregateDiscoveredResourceCountsEndpointParamsInterceptor;
  232    298   
  233    299   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAggregateDiscoveredResourceCountsEndpointParamsInterceptor {
  234    300   
    fn name(&self) -> &'static str {
  235    301   
        "GetAggregateDiscoveredResourceCountsEndpointParamsInterceptor"
  236    302   
    }
  237    303

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_discovered_resource_counts/_get_aggregate_discovered_resource_counts_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_discovered_resource_counts/_get_aggregate_discovered_resource_counts_output.rs

@@ -19,19 +189,247 @@
   39     39   
    "GetAggregateDiscoveredResourceCountsOutput",
   40     40   
);
   41     41   
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_TOTAL_DISCOVERED_RESOURCES: ::aws_smithy_schema::Schema =
   42     42   
    ::aws_smithy_schema::Schema::new_member(
   43     43   
        ::aws_smithy_schema::ShapeId::from_static(
   44     44   
            "com.amazonaws.configservice.synthetic#GetAggregateDiscoveredResourceCountsOutput$TotalDiscoveredResources",
   45     45   
            "com.amazonaws.configservice.synthetic",
   46     46   
            "GetAggregateDiscoveredResourceCountsOutput",
   47     47   
        ),
   48     48   
        ::aws_smithy_schema::ShapeType::Long,
   49         -
        "total_discovered_resources",
          49  +
        "TotalDiscoveredResources",
   50     50   
        0,
   51     51   
    );
   52     52   
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUP_BY_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   53     53   
    ::aws_smithy_schema::ShapeId::from_static(
   54     54   
        "com.amazonaws.configservice.synthetic#GetAggregateDiscoveredResourceCountsOutput$GroupByKey",
   55     55   
        "com.amazonaws.configservice.synthetic",
   56     56   
        "GetAggregateDiscoveredResourceCountsOutput",
   57     57   
    ),
   58     58   
    ::aws_smithy_schema::ShapeType::String,
   59         -
    "group_by_key",
          59  +
    "GroupByKey",
   60     60   
    1,
   61     61   
);
   62     62   
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUPED_RESOURCE_COUNTS: ::aws_smithy_schema::Schema =
   63     63   
    ::aws_smithy_schema::Schema::new_member(
   64     64   
        ::aws_smithy_schema::ShapeId::from_static(
   65     65   
            "com.amazonaws.configservice.synthetic#GetAggregateDiscoveredResourceCountsOutput$GroupedResourceCounts",
   66     66   
            "com.amazonaws.configservice.synthetic",
   67     67   
            "GetAggregateDiscoveredResourceCountsOutput",
   68     68   
        ),
   69     69   
        ::aws_smithy_schema::ShapeType::List,
   70         -
        "grouped_resource_counts",
          70  +
        "GroupedResourceCounts",
   71     71   
        2,
   72     72   
    );
   73     73   
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_NEXT_TOKEN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.configservice.synthetic#GetAggregateDiscoveredResourceCountsOutput$NextToken",
   76     76   
        "com.amazonaws.configservice.synthetic",
   77     77   
        "GetAggregateDiscoveredResourceCountsOutput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::String,
   80         -
    "next_token",
          80  +
    "NextToken",
   81     81   
    3,
   82     82   
);
          83  +
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          84  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          85  +
    ::aws_smithy_schema::ShapeType::String,
          86  +
    "request_id",
          87  +
    4,
          88  +
)
          89  +
.with_http_header("x-amzn-requestid");
   83     90   
static GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     91   
    GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA_ID,
   85     92   
    ::aws_smithy_schema::ShapeType::Structure,
   86     93   
    &[
   87     94   
        &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_TOTAL_DISCOVERED_RESOURCES,
   88     95   
        &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUP_BY_KEY,
   89     96   
        &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUPED_RESOURCE_COUNTS,
   90     97   
        &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_NEXT_TOKEN,
          98  +
        &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER__REQUEST_ID,
   91     99   
    ],
   92    100   
);
   93    101   
impl GetAggregateDiscoveredResourceCountsOutput {
   94    102   
    /// The schema for this shape.
   95    103   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA;
   96    104   
}
   97    105   
impl ::aws_smithy_schema::serde::SerializableStruct for GetAggregateDiscoveredResourceCountsOutput {
   98    106   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99    107   
    fn serialize_members(
  100    108   
        &self,
  101    109   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    110   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    111   
        {
  104    112   
            let val = &self.total_discovered_resources;
  105    113   
            ser.write_long(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_TOTAL_DISCOVERED_RESOURCES, *val)?;
  106    114   
        }
  107    115   
        if let Some(ref val) = self.group_by_key {
  108    116   
            ser.write_string(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUP_BY_KEY, val)?;
  109    117   
        }
  110    118   
        if let Some(ref val) = self.grouped_resource_counts {
  111    119   
            ser.write_list(
  112    120   
                &GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_GROUPED_RESOURCE_COUNTS,
  113    121   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  114    122   
                    for item in val {
  115    123   
                        ser.write_struct(crate::types::GroupedResourceCount::SCHEMA, item)?;
  116    124   
                    }
  117    125   
                    Ok(())
  118    126   
                },
  119    127   
            )?;
  120    128   
        }
  121    129   
        if let Some(ref val) = self.next_token {
  122    130   
            ser.write_string(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_MEMBER_NEXT_TOKEN, val)?;
  123    131   
        }
  124    132   
        Ok(())
  125    133   
    }
  126    134   
}
  127    135   
impl GetAggregateDiscoveredResourceCountsOutput {
  128    136   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  129         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  130         -
        deserializer: &mut D,
         137  +
    pub fn deserialize(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  131    139   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  132    140   
        #[allow(unused_variables, unused_mut)]
  133    141   
        let mut builder = Self::builder();
  134    142   
        #[allow(
  135    143   
            unused_variables,
  136    144   
            unreachable_code,
  137    145   
            clippy::single_match,
  138    146   
            clippy::match_single_binding,
  139    147   
            clippy::diverging_sub_expression
  140    148   
        )]
  141         -
        deserializer.read_struct(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA, (), |_, member, deser| {
         149  +
        deserializer.read_struct(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA, &mut |member, deser| {
  142    150   
            match member.member_index() {
  143    151   
                Some(0) => {
  144    152   
                    builder.total_discovered_resources = Some(deser.read_long(member)?);
  145    153   
                }
  146    154   
                Some(1) => {
  147    155   
                    builder.group_by_key = Some(deser.read_string(member)?);
  148    156   
                }
  149    157   
                Some(2) => {
  150    158   
                    builder.grouped_resource_counts = Some({
  151         -
                        let container = if let Some(cap) = deser.container_size() {
  152         -
                            Vec::with_capacity(cap)
  153         -
                        } else {
  154         -
                            Vec::new()
  155         -
                        };
  156         -
                        deser.read_list(member, container, |mut list, deser| {
  157         -
                            list.push(crate::types::GroupedResourceCount::deserialize(deser)?);
  158         -
                            Ok(list)
  159         -
                        })?
         159  +
                        let mut container = Vec::new();
         160  +
                        deser.read_list(member, &mut |deser| {
         161  +
                            container.push(crate::types::GroupedResourceCount::deserialize(deser)?);
         162  +
                            Ok(())
         163  +
                        })?;
         164  +
                        container
         165  +
                    });
         166  +
                }
         167  +
                Some(3) => {
         168  +
                    builder.next_token = Some(deser.read_string(member)?);
         169  +
                }
         170  +
                Some(4) => {
         171  +
                    builder._request_id = Some(deser.read_string(member)?);
         172  +
                }
         173  +
                _ => {}
         174  +
            }
         175  +
            Ok(())
         176  +
        })?;
         177  +
        Ok(builder.build())
         178  +
    }
         179  +
}
         180  +
impl GetAggregateDiscoveredResourceCountsOutput {
         181  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         182  +
    /// Header-bound members are read directly from headers, avoiding runtime
         183  +
    /// member iteration overhead. Body members are read via the deserializer.
         184  +
    pub fn deserialize_with_response(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         186  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         187  +
        _status: u16,
         188  +
        _body: &[u8],
         189  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         190  +
        #[allow(unused_variables, unused_mut)]
         191  +
        let mut builder = Self::builder();
         192  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         193  +
            builder._request_id = Some(val.to_string());
         194  +
        }
         195  +
        #[allow(
         196  +
            unused_variables,
         197  +
            unreachable_code,
         198  +
            clippy::single_match,
         199  +
            clippy::match_single_binding,
         200  +
            clippy::diverging_sub_expression
         201  +
        )]
         202  +
        deserializer.read_struct(&GETAGGREGATEDISCOVEREDRESOURCECOUNTSOUTPUT_SCHEMA, &mut |member, deser| {
         203  +
            match member.member_index() {
         204  +
                Some(0) => {
         205  +
                    builder.total_discovered_resources = Some(deser.read_long(member)?);
         206  +
                }
         207  +
                Some(1) => {
         208  +
                    builder.group_by_key = Some(deser.read_string(member)?);
         209  +
                }
         210  +
                Some(2) => {
         211  +
                    builder.grouped_resource_counts = Some({
         212  +
                        let mut container = Vec::new();
         213  +
                        deser.read_list(member, &mut |deser| {
         214  +
                            container.push(crate::types::GroupedResourceCount::deserialize(deser)?);
         215  +
                            Ok(())
         216  +
                        })?;
         217  +
                        container
  160    218   
                    });
  161    219   
                }
  162    220   
                Some(3) => {
  163    221   
                    builder.next_token = Some(deser.read_string(member)?);
  164    222   
                }
  165    223   
                _ => {}
  166    224   
            }
  167    225   
            Ok(())
  168    226   
        })?;
  169    227   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/config/src/operation/get_aggregate_resource_config.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GetAggregateResourceConfig`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GetAggregateResourceConfig;
    6      6   
impl GetAggregateResourceConfig {
    7      7   
    /// Creates a new `GetAggregateResourceConfig`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +253,372 @@
  144    150   
                crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GetAggregateResourceConfigResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GetAggregateResourceConfigResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_get_aggregate_resource_config::de_get_aggregate_resource_config_http_error(status, headers, body)
  166         -
        } else {
  167         -
            crate::protocol_serde::shape_get_aggregate_resource_config::de_get_aggregate_resource_config_http_response(status, headers, body)
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                ::std::option::Option::Some(code) => code,
         180  +
                ::std::option::Option::None => {
         181  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         182  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         183  +
                            crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::unhandled(generic),
         184  +
                        ),
         185  +
                    ))
         186  +
                }
         187  +
            };
         188  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         189  +
            let protocol = _cfg
         190  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         191  +
                .expect("a SharedClientProtocol is required");
         192  +
            let err = match error_code {
         193  +
                "NoSuchConfigurationAggregatorException" => {
         194  +
                    crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::NoSuchConfigurationAggregatorException({
         195  +
                        let mut tmp = match protocol
         196  +
                            .deserialize_response(response, crate::types::error::NoSuchConfigurationAggregatorException::SCHEMA, _cfg)
         197  +
                            .and_then(|mut deser| {
         198  +
                                crate::types::error::NoSuchConfigurationAggregatorException::deserialize_with_response(
         199  +
                                    &mut *deser,
         200  +
                                    response.headers(),
         201  +
                                    response.status().into(),
         202  +
                                    body,
         203  +
                                )
         204  +
                            }) {
         205  +
                            ::std::result::Result::Ok(val) => val,
         206  +
                            ::std::result::Result::Err(e) => {
         207  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         208  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         209  +
                                ))
         210  +
                            }
         211  +
                        };
         212  +
                        tmp.meta = generic;
         213  +
                        if tmp.message.is_none() {
         214  +
                            tmp.message = _error_message;
         215  +
                        }
         216  +
                        tmp
         217  +
                    })
         218  +
                }
         219  +
                "OversizedConfigurationItemException" => {
         220  +
                    crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::OversizedConfigurationItemException({
         221  +
                        let mut tmp = match protocol
         222  +
                            .deserialize_response(response, crate::types::error::OversizedConfigurationItemException::SCHEMA, _cfg)
         223  +
                            .and_then(|mut deser| {
         224  +
                                crate::types::error::OversizedConfigurationItemException::deserialize_with_response(
         225  +
                                    &mut *deser,
         226  +
                                    response.headers(),
         227  +
                                    response.status().into(),
         228  +
                                    body,
         229  +
                                )
         230  +
                            }) {
         231  +
                            ::std::result::Result::Ok(val) => val,
         232  +
                            ::std::result::Result::Err(e) => {
         233  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         234  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         235  +
                                ))
         236  +
                            }
  168    237   
                        };
  169         -
        crate::protocol_serde::type_erase_result(parse_result)
         238  +
                        tmp.meta = generic;
         239  +
                        if tmp.message.is_none() {
         240  +
                            tmp.message = _error_message;
         241  +
                        }
         242  +
                        tmp
         243  +
                    })
         244  +
                }
         245  +
                "ResourceNotDiscoveredException" => {
         246  +
                    crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::ResourceNotDiscoveredException({
         247  +
                        let mut tmp = match protocol
         248  +
                            .deserialize_response(response, crate::types::error::ResourceNotDiscoveredException::SCHEMA, _cfg)
         249  +
                            .and_then(|mut deser| {
         250  +
                                crate::types::error::ResourceNotDiscoveredException::deserialize_with_response(
         251  +
                                    &mut *deser,
         252  +
                                    response.headers(),
         253  +
                                    response.status().into(),
         254  +
                                    body,
         255  +
                                )
         256  +
                            }) {
         257  +
                            ::std::result::Result::Ok(val) => val,
         258  +
                            ::std::result::Result::Err(e) => {
         259  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         260  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         261  +
                                ))
         262  +
                            }
         263  +
                        };
         264  +
                        tmp.meta = generic;
         265  +
                        if tmp.message.is_none() {
         266  +
                            tmp.message = _error_message;
         267  +
                        }
         268  +
                        tmp
         269  +
                    })
         270  +
                }
         271  +
                "ValidationException" => crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::ValidationException({
         272  +
                    let mut tmp = match protocol
         273  +
                        .deserialize_response(response, crate::types::error::ValidationException::SCHEMA, _cfg)
         274  +
                        .and_then(|mut deser| {
         275  +
                            crate::types::error::ValidationException::deserialize_with_response(
         276  +
                                &mut *deser,
         277  +
                                response.headers(),
         278  +
                                response.status().into(),
         279  +
                                body,
         280  +
                            )
         281  +
                        }) {
         282  +
                        ::std::result::Result::Ok(val) => val,
         283  +
                        ::std::result::Result::Err(e) => {
         284  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         285  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         286  +
                            ))
         287  +
                        }
         288  +
                    };
         289  +
                    tmp.meta = generic;
         290  +
                    if tmp.message.is_none() {
         291  +
                        tmp.message = _error_message;
         292  +
                    }
         293  +
                    tmp
         294  +
                }),
         295  +
                _ => crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigError::generic(generic),
         296  +
            };
         297  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         298  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         299  +
            ))
         300  +
        } else {
         301  +
            let protocol = _cfg
         302  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         303  +
                .expect("a SharedClientProtocol is required");
         304  +
            let mut deser = protocol
         305  +
                .deserialize_response(response, GetAggregateResourceConfig::OUTPUT_SCHEMA, _cfg)
         306  +
                .map_err(|e| {
         307  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         308  +
                })?;
         309  +
            let body = response.body().bytes().expect("body loaded");
         310  +
            let output = crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigOutput::deserialize_with_response(
         311  +
                &mut *deser,
         312  +
                response.headers(),
         313  +
                response.status().into(),
         314  +
                body,
         315  +
            )
         316  +
            .map_err(|e| {
         317  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         318  +
            })?;
         319  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         320  +
        }
  170    321   
    }
  171    322   
}
  172    323   
#[derive(Debug)]
  173    324   
struct GetAggregateResourceConfigRequestSerializer;
  174    325   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GetAggregateResourceConfigRequestSerializer {
  175    326   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  176    327   
    fn serialize_input(
  177    328   
        &self,
  178    329   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  179    330   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  180    331   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  181    332   
        let input = input
  182    333   
            .downcast::<crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigInput>()
  183    334   
            .expect("correct type");
  184         -
        let _header_serialization_settings = _cfg
  185         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  186         -
            .cloned()
  187         -
            .unwrap_or_default();
  188         -
        let mut request_builder = {
  189         -
            #[allow(clippy::uninlined_format_args)]
  190         -
            fn uri_base(
  191         -
                _input: &crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigInput,
  192         -
                output: &mut ::std::string::String,
  193         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194         -
                use ::std::fmt::Write as _;
  195         -
                ::std::write!(output, "/").expect("formatting should succeed");
  196         -
                ::std::result::Result::Ok(())
  197         -
            }
  198         -
            #[allow(clippy::unnecessary_wraps)]
  199         -
            fn update_http_builder(
  200         -
                input: &crate::operation::get_aggregate_resource_config::GetAggregateResourceConfigInput,
  201         -
                builder: ::http_1x::request::Builder,
  202         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  203         -
                let mut uri = ::std::string::String::new();
  204         -
                uri_base(input, &mut uri)?;
  205         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  206         -
            }
  207         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  208         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  209         -
            builder = _header_serialization_settings.set_default_header(
  210         -
                builder,
  211         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212         -
                "StarlingDoveService.GetAggregateResourceConfig",
  213         -
            );
  214         -
            builder
  215         -
        };
  216         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  217         -
            crate::protocol_serde::shape_get_aggregate_resource_config::ser_get_aggregate_resource_config_input(&input)?,
  218         -
        );
  219         -
        if let Some(content_length) = body.content_length() {
  220         -
            let content_length = content_length.to_string();
  221         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  222         -
        }
  223         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         335  +
        let protocol = _cfg
         336  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         337  +
            .expect("a SharedClientProtocol is required");
         338  +
        let mut request = protocol
         339  +
            .serialize_request(&input, GetAggregateResourceConfig::INPUT_SCHEMA, "", _cfg)
         340  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         341  +
         342  +
        return ::std::result::Result::Ok(request);
  224    343   
    }
  225    344   
}
  226    345   
#[derive(Debug)]
  227    346   
struct GetAggregateResourceConfigEndpointParamsInterceptor;
  228    347   
  229    348   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GetAggregateResourceConfigEndpointParamsInterceptor {
  230    349   
    fn name(&self) -> &'static str {
  231    350   
        "GetAggregateResourceConfigEndpointParamsInterceptor"
  232    351   
    }
  233    352