AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_image/_deregister_image_input.rs

@@ -16,16 +164,176 @@
   36     36   
    "com.amazonaws.ec2.synthetic",
   37     37   
    "DeregisterImageInput",
   38     38   
);
   39     39   
static DEREGISTERIMAGEINPUT_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   40     40   
    ::aws_smithy_schema::ShapeId::from_static(
   41     41   
        "com.amazonaws.ec2.synthetic#DeregisterImageInput$ImageId",
   42     42   
        "com.amazonaws.ec2.synthetic",
   43     43   
        "DeregisterImageInput",
   44     44   
    ),
   45     45   
    ::aws_smithy_schema::ShapeType::String,
   46         -
    "image_id",
          46  +
    "ImageId",
   47     47   
    0,
   48     48   
);
   49     49   
static DEREGISTERIMAGEINPUT_MEMBER_DELETE_ASSOCIATED_SNAPSHOTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.ec2.synthetic#DeregisterImageInput$DeleteAssociatedSnapshots",
   52     52   
        "com.amazonaws.ec2.synthetic",
   53     53   
        "DeregisterImageInput",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::Boolean,
   56         -
    "delete_associated_snapshots",
          56  +
    "DeleteAssociatedSnapshots",
   57     57   
    1,
   58     58   
);
   59     59   
static DEREGISTERIMAGEINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2.synthetic#DeregisterImageInput$DryRun",
   62     62   
        "com.amazonaws.ec2.synthetic",
   63     63   
        "DeregisterImageInput",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Boolean,
   66         -
    "dry_run",
          66  +
    "DryRun",
   67     67   
    2,
   68     68   
)
   69     69   
.with_xml_name("dryRun");
   70     70   
static DEREGISTERIMAGEINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   71     71   
    DEREGISTERIMAGEINPUT_SCHEMA_ID,
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73     73   
    &[
   74     74   
        &DEREGISTERIMAGEINPUT_MEMBER_IMAGE_ID,
   75     75   
        &DEREGISTERIMAGEINPUT_MEMBER_DELETE_ASSOCIATED_SNAPSHOTS,
   76     76   
        &DEREGISTERIMAGEINPUT_MEMBER_DRY_RUN,
   77     77   
    ],
   78     78   
);
   79     79   
impl DeregisterImageInput {
   80     80   
    /// The schema for this shape.
   81     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERIMAGEINPUT_SCHEMA;
   82     82   
}
   83     83   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterImageInput {
   84     84   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   85     85   
    fn serialize_members(
   86     86   
        &self,
   87     87   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   88     88   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        if let Some(ref val) = self.image_id {
   90     90   
            ser.write_string(&DEREGISTERIMAGEINPUT_MEMBER_IMAGE_ID, val)?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.delete_associated_snapshots {
   93     93   
            ser.write_boolean(&DEREGISTERIMAGEINPUT_MEMBER_DELETE_ASSOCIATED_SNAPSHOTS, *val)?;
   94     94   
        }
   95     95   
        if let Some(ref val) = self.dry_run {
   96     96   
            ser.write_boolean(&DEREGISTERIMAGEINPUT_MEMBER_DRY_RUN, *val)?;
   97     97   
        }
   98     98   
        Ok(())
   99     99   
    }
  100    100   
}
  101    101   
impl DeregisterImageInput {
  102    102   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  103         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  104         -
        deserializer: &mut D,
         103  +
    pub fn deserialize(
         104  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  105    105   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  106    106   
        #[allow(unused_variables, unused_mut)]
  107    107   
        let mut builder = Self::builder();
  108    108   
        #[allow(
  109    109   
            unused_variables,
  110    110   
            unreachable_code,
  111    111   
            clippy::single_match,
  112    112   
            clippy::match_single_binding,
  113    113   
            clippy::diverging_sub_expression
  114    114   
        )]
  115         -
        deserializer.read_struct(&DEREGISTERIMAGEINPUT_SCHEMA, (), |_, member, deser| {
         115  +
        deserializer.read_struct(&DEREGISTERIMAGEINPUT_SCHEMA, &mut |member, deser| {
  116    116   
            match member.member_index() {
  117    117   
                Some(0) => {
  118    118   
                    builder.image_id = Some(deser.read_string(member)?);
  119    119   
                }
  120    120   
                Some(1) => {
  121    121   
                    builder.delete_associated_snapshots = Some(deser.read_boolean(member)?);
  122    122   
                }
  123    123   
                Some(2) => {
  124    124   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  125    125   
                }
  126    126   
                _ => {}
  127    127   
            }
  128    128   
            Ok(())
  129    129   
        })?;
         130  +
        builder.image_id = builder.image_id.or(Some(String::new()));
  130    131   
        builder
  131    132   
            .build()
  132    133   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  133    134   
    }
  134    135   
}
         136  +
impl DeregisterImageInput {
         137  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         138  +
    pub fn deserialize_with_response(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         140  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         141  +
        _status: u16,
         142  +
        _body: &[u8],
         143  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         144  +
        Self::deserialize(deserializer)
         145  +
    }
         146  +
}
  135    147   
impl DeregisterImageInput {
  136    148   
    /// Creates a new builder-style object to manufacture [`DeregisterImageInput`](crate::operation::deregister_image::DeregisterImageInput).
  137    149   
    pub fn builder() -> crate::operation::deregister_image::builders::DeregisterImageInputBuilder {
  138    150   
        crate::operation::deregister_image::builders::DeregisterImageInputBuilder::default()
  139    151   
    }
  140    152   
}
  141    153   
  142    154   
/// A builder for [`DeregisterImageInput`](crate::operation::deregister_image::DeregisterImageInput).
  143    155   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  144    156   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_image/_deregister_image_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_instance_event_notification_attributes.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 `DeregisterInstanceEventNotificationAttributes`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DeregisterInstanceEventNotificationAttributes;
    6      6   
impl DeregisterInstanceEventNotificationAttributes {
    7      7   
    /// Creates a new `DeregisterInstanceEventNotificationAttributes`
    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::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesOutput::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::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -128,134 +187,194 @@
  148    154   
        ::std::borrow::Cow::Owned(rcb)
  149    155   
    }
  150    156   
}
  151    157   
  152    158   
#[derive(Debug)]
  153    159   
struct DeregisterInstanceEventNotificationAttributesResponseDeserializer;
  154    160   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeregisterInstanceEventNotificationAttributesResponseDeserializer {
  155    161   
    fn deserialize_nonstreaming(
  156    162   
        &self,
  157    163   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         164  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  158    165   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  159    166   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  160    167   
        let headers = response.headers();
  161    168   
        let body = response.body().bytes().expect("body loaded");
  162    169   
        #[allow(unused_mut)]
  163    170   
        let mut force_error = false;
  164    171   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  165    172   
        let parse_result = if !success && status != 200 || force_error {
  166    173   
            crate::protocol_serde::shape_deregister_instance_event_notification_attributes::de_deregister_instance_event_notification_attributes_http_error(status, headers, body)
  167    174   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_instance_event_notification_attributes/_deregister_instance_event_notification_attributes_input.rs

@@ -3,3 +134,145 @@
   23     23   
    "com.amazonaws.ec2.synthetic",
   24     24   
    "DeregisterInstanceEventNotificationAttributesInput",
   25     25   
);
   26     26   
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static(
   28     28   
        "com.amazonaws.ec2.synthetic#DeregisterInstanceEventNotificationAttributesInput$DryRun",
   29     29   
        "com.amazonaws.ec2.synthetic",
   30     30   
        "DeregisterInstanceEventNotificationAttributesInput",
   31     31   
    ),
   32     32   
    ::aws_smithy_schema::ShapeType::Boolean,
   33         -
    "dry_run",
          33  +
    "DryRun",
   34     34   
    0,
   35     35   
);
   36     36   
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE: ::aws_smithy_schema::Schema =
   37     37   
    ::aws_smithy_schema::Schema::new_member(
   38     38   
        ::aws_smithy_schema::ShapeId::from_static(
   39     39   
            "com.amazonaws.ec2.synthetic#DeregisterInstanceEventNotificationAttributesInput$InstanceTagAttribute",
   40     40   
            "com.amazonaws.ec2.synthetic",
   41     41   
            "DeregisterInstanceEventNotificationAttributesInput",
   42     42   
        ),
   43     43   
        ::aws_smithy_schema::ShapeType::Structure,
   44         -
        "instance_tag_attribute",
          44  +
        "InstanceTagAttribute",
   45     45   
        1,
   46     46   
    );
   47     47   
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   48     48   
    DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_SCHEMA_ID,
   49     49   
    ::aws_smithy_schema::ShapeType::Structure,
   50     50   
    &[
   51     51   
        &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_DRY_RUN,
   52     52   
        &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE,
   53     53   
    ],
   54     54   
);
   55     55   
impl DeregisterInstanceEventNotificationAttributesInput {
   56     56   
    /// The schema for this shape.
   57     57   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_SCHEMA;
   58     58   
}
   59     59   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterInstanceEventNotificationAttributesInput {
   60     60   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   61     61   
    fn serialize_members(
   62     62   
        &self,
   63     63   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   64     64   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        if let Some(ref val) = self.dry_run {
   66     66   
            ser.write_boolean(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_DRY_RUN, *val)?;
   67     67   
        }
   68     68   
        if let Some(ref val) = self.instance_tag_attribute {
   69     69   
            ser.write_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE, val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl DeregisterInstanceEventNotificationAttributesInput {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESINPUT_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.dry_run = Some(deser.read_boolean(member)?);
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.instance_tag_attribute = Some(crate::types::DeregisterInstanceTagAttributeRequest::deserialize(deser)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
  100    100   
        builder
  101    101   
            .build()
  102    102   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  103    103   
    }
  104    104   
}
         105  +
impl DeregisterInstanceEventNotificationAttributesInput {
         106  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         107  +
    pub fn deserialize_with_response(
         108  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         109  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         110  +
        _status: u16,
         111  +
        _body: &[u8],
         112  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         113  +
        Self::deserialize(deserializer)
         114  +
    }
         115  +
}
  105    116   
impl DeregisterInstanceEventNotificationAttributesInput {
  106    117   
    /// Creates a new builder-style object to manufacture [`DeregisterInstanceEventNotificationAttributesInput`](crate::operation::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesInput).
  107    118   
    pub fn builder(
  108    119   
    ) -> crate::operation::deregister_instance_event_notification_attributes::builders::DeregisterInstanceEventNotificationAttributesInputBuilder
  109    120   
    {
  110    121   
        crate::operation::deregister_instance_event_notification_attributes::builders::DeregisterInstanceEventNotificationAttributesInputBuilder::default()
  111    122   
    }
  112    123   
}
  113    124   
  114    125   
/// A builder for [`DeregisterInstanceEventNotificationAttributesInput`](crate::operation::deregister_instance_event_notification_attributes::DeregisterInstanceEventNotificationAttributesInput).

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_instance_event_notification_attributes/_deregister_instance_event_notification_attributes_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "DeregisterInstanceEventNotificationAttributesOutput",
   20     20   
);
   21     21   
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.ec2.synthetic#DeregisterInstanceEventNotificationAttributesOutput$InstanceTagAttribute",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "DeregisterInstanceEventNotificationAttributesOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "instance_tag_attribute",
          29  +
        "InstanceTagAttribute",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("instanceTagAttribute");
          33  +
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE],
          43  +
    &[
          44  +
        &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE,
          45  +
        &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl DeregisterInstanceEventNotificationAttributesOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterInstanceEventNotificationAttributesOutput {
   43     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     54   
    fn serialize_members(
   45     55   
        &self,
   46     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     58   
        if let Some(ref val) = self.instance_tag_attribute {
   49     59   
            ser.write_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_MEMBER_INSTANCE_TAG_ATTRIBUTE, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl DeregisterInstanceEventNotificationAttributesOutput {
   55     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   56         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   57         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   58     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   59     69   
        #[allow(unused_variables, unused_mut)]
   60     70   
        let mut builder = Self::builder();
   61     71   
        #[allow(
   62     72   
            unused_variables,
   63     73   
            unreachable_code,
   64     74   
            clippy::single_match,
   65     75   
            clippy::match_single_binding,
   66     76   
            clippy::diverging_sub_expression
   67     77   
        )]
   68         -
        deserializer.read_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.instance_tag_attribute = Some(crate::types::InstanceTagNotificationAttribute::deserialize(deser)?);
          82  +
                }
          83  +
                Some(1) => {
          84  +
                    builder._request_id = Some(deser.read_string(member)?);
          85  +
                }
          86  +
                _ => {}
          87  +
            }
          88  +
            Ok(())
          89  +
        })?;
          90  +
        Ok(builder.build())
          91  +
    }
          92  +
}
          93  +
impl DeregisterInstanceEventNotificationAttributesOutput {
          94  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          95  +
    /// Header-bound members are read directly from headers, avoiding runtime
          96  +
    /// member iteration overhead. Body members are read via the deserializer.
          97  +
    pub fn deserialize_with_response(
          98  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          99  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         100  +
        _status: u16,
         101  +
        _body: &[u8],
         102  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         103  +
        #[allow(unused_variables, unused_mut)]
         104  +
        let mut builder = Self::builder();
         105  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         106  +
            builder._request_id = Some(val.to_string());
         107  +
        }
         108  +
        #[allow(
         109  +
            unused_variables,
         110  +
            unreachable_code,
         111  +
            clippy::single_match,
         112  +
            clippy::match_single_binding,
         113  +
            clippy::diverging_sub_expression
         114  +
        )]
         115  +
        deserializer.read_struct(&DEREGISTERINSTANCEEVENTNOTIFICATIONATTRIBUTESOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.instance_tag_attribute = Some(crate::types::InstanceTagNotificationAttribute::deserialize(deser)?);
   72    119   
                }
   73    120   
                _ => {}
   74    121   
            }
   75    122   
            Ok(())
   76    123   
        })?;
   77    124   
        Ok(builder.build())
   78    125   
    }

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_members.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 `DeregisterTransitGatewayMulticastGroupMembers`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DeregisterTransitGatewayMulticastGroupMembers;
    6      6   
impl DeregisterTransitGatewayMulticastGroupMembers {
    7      7   
    /// Creates a new `DeregisterTransitGatewayMulticastGroupMembers`
    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::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersOutput::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::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -123,129 +182,189 @@
  143    149   
        ::std::borrow::Cow::Owned(rcb)
  144    150   
    }
  145    151   
}
  146    152   
  147    153   
#[derive(Debug)]
  148    154   
struct DeregisterTransitGatewayMulticastGroupMembersResponseDeserializer;
  149    155   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeregisterTransitGatewayMulticastGroupMembersResponseDeserializer {
  150    156   
    fn deserialize_nonstreaming(
  151    157   
        &self,
  152    158   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         159  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  153    160   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  154    161   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  155    162   
        let headers = response.headers();
  156    163   
        let body = response.body().bytes().expect("body loaded");
  157    164   
        #[allow(unused_mut)]
  158    165   
        let mut force_error = false;
  159    166   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  160    167   
        let parse_result = if !success && status != 200 || force_error {
  161    168   
            crate::protocol_serde::shape_deregister_transit_gateway_multicast_group_members::de_deregister_transit_gateway_multicast_group_members_http_error(status, headers, body)
  162    169   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_members/_deregister_transit_gateway_multicast_group_members_input.rs

@@ -18,18 +205,206 @@
   38     38   
    "DeregisterTransitGatewayMulticastGroupMembersInput",
   39     39   
);
   40     40   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID: ::aws_smithy_schema::Schema =
   41     41   
    ::aws_smithy_schema::Schema::new_member(
   42     42   
        ::aws_smithy_schema::ShapeId::from_static(
   43     43   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupMembersInput$TransitGatewayMulticastDomainId",
   44     44   
            "com.amazonaws.ec2.synthetic",
   45     45   
            "DeregisterTransitGatewayMulticastGroupMembersInput",
   46     46   
        ),
   47     47   
        ::aws_smithy_schema::ShapeType::String,
   48         -
        "transit_gateway_multicast_domain_id",
          48  +
        "TransitGatewayMulticastDomainId",
   49     49   
        0,
   50     50   
    );
   51     51   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_GROUP_IP_ADDRESS: ::aws_smithy_schema::Schema =
   52     52   
    ::aws_smithy_schema::Schema::new_member(
   53     53   
        ::aws_smithy_schema::ShapeId::from_static(
   54     54   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupMembersInput$GroupIpAddress",
   55     55   
            "com.amazonaws.ec2.synthetic",
   56     56   
            "DeregisterTransitGatewayMulticastGroupMembersInput",
   57     57   
        ),
   58     58   
        ::aws_smithy_schema::ShapeType::String,
   59         -
        "group_ip_address",
          59  +
        "GroupIpAddress",
   60     60   
        1,
   61     61   
    );
   62     62   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_NETWORK_INTERFACE_IDS: ::aws_smithy_schema::Schema =
   63     63   
    ::aws_smithy_schema::Schema::new_member(
   64     64   
        ::aws_smithy_schema::ShapeId::from_static(
   65     65   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupMembersInput$NetworkInterfaceIds",
   66     66   
            "com.amazonaws.ec2.synthetic",
   67     67   
            "DeregisterTransitGatewayMulticastGroupMembersInput",
   68     68   
        ),
   69     69   
        ::aws_smithy_schema::ShapeType::List,
   70         -
        "network_interface_ids",
          70  +
        "NetworkInterfaceIds",
   71     71   
        2,
   72     72   
    );
   73     73   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupMembersInput$DryRun",
   76     76   
        "com.amazonaws.ec2.synthetic",
   77     77   
        "DeregisterTransitGatewayMulticastGroupMembersInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Boolean,
   80         -
    "dry_run",
          80  +
    "DryRun",
   81     81   
    3,
   82     82   
);
   83     83   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID,
   88     88   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_GROUP_IP_ADDRESS,
   89     89   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_NETWORK_INTERFACE_IDS,
   90     90   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_DRY_RUN,
   91     91   
    ],
   92     92   
);
   93     93   
impl DeregisterTransitGatewayMulticastGroupMembersInput {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterTransitGatewayMulticastGroupMembersInput {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        if let Some(ref val) = self.transit_gateway_multicast_domain_id {
  104    104   
            ser.write_string(
  105    105   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID,
  106    106   
                val,
  107    107   
            )?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.group_ip_address {
  110    110   
            ser.write_string(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_GROUP_IP_ADDRESS, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.network_interface_ids {
  113    113   
            ser.write_list(
  114    114   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_NETWORK_INTERFACE_IDS,
  115    115   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  116    116   
                    for item in val {
  117    117   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  118    118   
                    }
  119    119   
                    Ok(())
  120    120   
                },
  121    121   
            )?;
  122    122   
        }
  123    123   
        if let Some(ref val) = self.dry_run {
  124    124   
            ser.write_boolean(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_MEMBER_DRY_RUN, *val)?;
  125    125   
        }
  126    126   
        Ok(())
  127    127   
    }
  128    128   
}
  129    129   
impl DeregisterTransitGatewayMulticastGroupMembersInput {
  130    130   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  131         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  132         -
        deserializer: &mut D,
         131  +
    pub fn deserialize(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  133    133   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  134    134   
        #[allow(unused_variables, unused_mut)]
  135    135   
        let mut builder = Self::builder();
  136    136   
        #[allow(
  137    137   
            unused_variables,
  138    138   
            unreachable_code,
  139    139   
            clippy::single_match,
  140    140   
            clippy::match_single_binding,
  141    141   
            clippy::diverging_sub_expression
  142    142   
        )]
  143         -
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_SCHEMA, (), |_, member, deser| {
         143  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSINPUT_SCHEMA, &mut |member, deser| {
  144    144   
            match member.member_index() {
  145    145   
                Some(0) => {
  146    146   
                    builder.transit_gateway_multicast_domain_id = Some(deser.read_string(member)?);
  147    147   
                }
  148    148   
                Some(1) => {
  149    149   
                    builder.group_ip_address = Some(deser.read_string(member)?);
  150    150   
                }
  151    151   
                Some(2) => {
  152         -
                    builder.network_interface_ids = Some({
  153         -
                        let container = if let Some(cap) = deser.container_size() {
  154         -
                            Vec::with_capacity(cap)
  155         -
                        } else {
  156         -
                            Vec::new()
  157         -
                        };
  158         -
                        deser.read_list(member, container, |mut list, deser| {
  159         -
                            list.push(deser.read_string(member)?);
  160         -
                            Ok(list)
  161         -
                        })?
  162         -
                    });
         152  +
                    builder.network_interface_ids = Some(deser.read_string_list(member)?);
  163    153   
                }
  164    154   
                Some(3) => {
  165    155   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  166    156   
                }
  167    157   
                _ => {}
  168    158   
            }
  169    159   
            Ok(())
  170    160   
        })?;
  171    161   
        builder
  172    162   
            .build()
  173    163   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  174    164   
    }
  175    165   
}
         166  +
impl DeregisterTransitGatewayMulticastGroupMembersInput {
         167  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         168  +
    pub fn deserialize_with_response(
         169  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         170  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         171  +
        _status: u16,
         172  +
        _body: &[u8],
         173  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         174  +
        Self::deserialize(deserializer)
         175  +
    }
         176  +
}
  176    177   
impl DeregisterTransitGatewayMulticastGroupMembersInput {
  177    178   
    /// Creates a new builder-style object to manufacture [`DeregisterTransitGatewayMulticastGroupMembersInput`](crate::operation::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersInput).
  178    179   
    pub fn builder(
  179    180   
    ) -> crate::operation::deregister_transit_gateway_multicast_group_members::builders::DeregisterTransitGatewayMulticastGroupMembersInputBuilder
  180    181   
    {
  181    182   
        crate::operation::deregister_transit_gateway_multicast_group_members::builders::DeregisterTransitGatewayMulticastGroupMembersInputBuilder::default()
  182    183   
    }
  183    184   
}
  184    185   
  185    186   
/// A builder for [`DeregisterTransitGatewayMulticastGroupMembersInput`](crate::operation::deregister_transit_gateway_multicast_group_members::DeregisterTransitGatewayMulticastGroupMembersInput).

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_members/_deregister_transit_gateway_multicast_group_members_output.rs

@@ -1,1 +101,149 @@
   19     19   
    "DeregisterTransitGatewayMulticastGroupMembersOutput",
   20     20   
);
   21     21   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_MEMBERS: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupMembersOutput$DeregisteredMulticastGroupMembers",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "DeregisterTransitGatewayMulticastGroupMembersOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "deregistered_multicast_group_members",
          29  +
        "DeregisteredMulticastGroupMembers",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("deregisteredMulticastGroupMembers");
          33  +
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_MEMBERS],
          43  +
    &[
          44  +
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_MEMBERS,
          45  +
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl DeregisterTransitGatewayMulticastGroupMembersOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterTransitGatewayMulticastGroupMembersOutput {
   43     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     54   
    fn serialize_members(
   45     55   
        &self,
   46     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     58   
        if let Some(ref val) = self.deregistered_multicast_group_members {
   49     59   
            ser.write_struct(
   50     60   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_MEMBERS,
   51     61   
                val,
   52     62   
            )?;
   53     63   
        }
   54     64   
        Ok(())
   55     65   
    }
   56     66   
}
   57     67   
impl DeregisterTransitGatewayMulticastGroupMembersOutput {
   58     68   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   59         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   60         -
        deserializer: &mut D,
          69  +
    pub fn deserialize(
          70  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          72  +
        #[allow(unused_variables, unused_mut)]
          73  +
        let mut builder = Self::builder();
          74  +
        #[allow(
          75  +
            unused_variables,
          76  +
            unreachable_code,
          77  +
            clippy::single_match,
          78  +
            clippy::match_single_binding,
          79  +
            clippy::diverging_sub_expression
          80  +
        )]
          81  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA, &mut |member, deser| {
          82  +
            match member.member_index() {
          83  +
                Some(0) => {
          84  +
                    builder.deregistered_multicast_group_members =
          85  +
                        Some(crate::types::TransitGatewayMulticastDeregisteredGroupMembers::deserialize(deser)?);
          86  +
                }
          87  +
                Some(1) => {
          88  +
                    builder._request_id = Some(deser.read_string(member)?);
          89  +
                }
          90  +
                _ => {}
          91  +
            }
          92  +
            Ok(())
          93  +
        })?;
          94  +
        Ok(builder.build())
          95  +
    }
          96  +
}
          97  +
impl DeregisterTransitGatewayMulticastGroupMembersOutput {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          99  +
    /// Header-bound members are read directly from headers, avoiding runtime
         100  +
    /// member iteration overhead. Body members are read via the deserializer.
         101  +
    pub fn deserialize_with_response(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         103  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         104  +
        _status: u16,
         105  +
        _body: &[u8],
   61    106   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   62    107   
        #[allow(unused_variables, unused_mut)]
   63    108   
        let mut builder = Self::builder();
         109  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         110  +
            builder._request_id = Some(val.to_string());
         111  +
        }
   64    112   
        #[allow(
   65    113   
            unused_variables,
   66    114   
            unreachable_code,
   67    115   
            clippy::single_match,
   68    116   
            clippy::match_single_binding,
   69    117   
            clippy::diverging_sub_expression
   70    118   
        )]
   71         -
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA, (), |_, member, deser| {
         119  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPMEMBERSOUTPUT_SCHEMA, &mut |member, deser| {
   72    120   
            match member.member_index() {
   73    121   
                Some(0) => {
   74    122   
                    builder.deregistered_multicast_group_members =
   75    123   
                        Some(crate::types::TransitGatewayMulticastDeregisteredGroupMembers::deserialize(deser)?);
   76    124   
                }
   77    125   
                _ => {}
   78    126   
            }
   79    127   
            Ok(())
   80    128   
        })?;
   81    129   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_sources.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 `DeregisterTransitGatewayMulticastGroupSources`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DeregisterTransitGatewayMulticastGroupSources;
    6      6   
impl DeregisterTransitGatewayMulticastGroupSources {
    7      7   
    /// Creates a new `DeregisterTransitGatewayMulticastGroupSources`
    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::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesOutput::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::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -123,129 +182,189 @@
  143    149   
        ::std::borrow::Cow::Owned(rcb)
  144    150   
    }
  145    151   
}
  146    152   
  147    153   
#[derive(Debug)]
  148    154   
struct DeregisterTransitGatewayMulticastGroupSourcesResponseDeserializer;
  149    155   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeregisterTransitGatewayMulticastGroupSourcesResponseDeserializer {
  150    156   
    fn deserialize_nonstreaming(
  151    157   
        &self,
  152    158   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         159  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  153    160   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  154    161   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  155    162   
        let headers = response.headers();
  156    163   
        let body = response.body().bytes().expect("body loaded");
  157    164   
        #[allow(unused_mut)]
  158    165   
        let mut force_error = false;
  159    166   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  160    167   
        let parse_result = if !success && status != 200 || force_error {
  161    168   
            crate::protocol_serde::shape_deregister_transit_gateway_multicast_group_sources::de_deregister_transit_gateway_multicast_group_sources_http_error(status, headers, body)
  162    169   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_sources/_deregister_transit_gateway_multicast_group_sources_input.rs

@@ -18,18 +205,206 @@
   38     38   
    "DeregisterTransitGatewayMulticastGroupSourcesInput",
   39     39   
);
   40     40   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID: ::aws_smithy_schema::Schema =
   41     41   
    ::aws_smithy_schema::Schema::new_member(
   42     42   
        ::aws_smithy_schema::ShapeId::from_static(
   43     43   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupSourcesInput$TransitGatewayMulticastDomainId",
   44     44   
            "com.amazonaws.ec2.synthetic",
   45     45   
            "DeregisterTransitGatewayMulticastGroupSourcesInput",
   46     46   
        ),
   47     47   
        ::aws_smithy_schema::ShapeType::String,
   48         -
        "transit_gateway_multicast_domain_id",
          48  +
        "TransitGatewayMulticastDomainId",
   49     49   
        0,
   50     50   
    );
   51     51   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_GROUP_IP_ADDRESS: ::aws_smithy_schema::Schema =
   52     52   
    ::aws_smithy_schema::Schema::new_member(
   53     53   
        ::aws_smithy_schema::ShapeId::from_static(
   54     54   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupSourcesInput$GroupIpAddress",
   55     55   
            "com.amazonaws.ec2.synthetic",
   56     56   
            "DeregisterTransitGatewayMulticastGroupSourcesInput",
   57     57   
        ),
   58     58   
        ::aws_smithy_schema::ShapeType::String,
   59         -
        "group_ip_address",
          59  +
        "GroupIpAddress",
   60     60   
        1,
   61     61   
    );
   62     62   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_NETWORK_INTERFACE_IDS: ::aws_smithy_schema::Schema =
   63     63   
    ::aws_smithy_schema::Schema::new_member(
   64     64   
        ::aws_smithy_schema::ShapeId::from_static(
   65     65   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupSourcesInput$NetworkInterfaceIds",
   66     66   
            "com.amazonaws.ec2.synthetic",
   67     67   
            "DeregisterTransitGatewayMulticastGroupSourcesInput",
   68     68   
        ),
   69     69   
        ::aws_smithy_schema::ShapeType::List,
   70         -
        "network_interface_ids",
          70  +
        "NetworkInterfaceIds",
   71     71   
        2,
   72     72   
    );
   73     73   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   74     74   
    ::aws_smithy_schema::ShapeId::from_static(
   75     75   
        "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupSourcesInput$DryRun",
   76     76   
        "com.amazonaws.ec2.synthetic",
   77     77   
        "DeregisterTransitGatewayMulticastGroupSourcesInput",
   78     78   
    ),
   79     79   
    ::aws_smithy_schema::ShapeType::Boolean,
   80         -
    "dry_run",
          80  +
    "DryRun",
   81     81   
    3,
   82     82   
);
   83     83   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   84     84   
    DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_SCHEMA_ID,
   85     85   
    ::aws_smithy_schema::ShapeType::Structure,
   86     86   
    &[
   87     87   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID,
   88     88   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_GROUP_IP_ADDRESS,
   89     89   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_NETWORK_INTERFACE_IDS,
   90     90   
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_DRY_RUN,
   91     91   
    ],
   92     92   
);
   93     93   
impl DeregisterTransitGatewayMulticastGroupSourcesInput {
   94     94   
    /// The schema for this shape.
   95     95   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_SCHEMA;
   96     96   
}
   97     97   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterTransitGatewayMulticastGroupSourcesInput {
   98     98   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   99     99   
    fn serialize_members(
  100    100   
        &self,
  101    101   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  102    102   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  103    103   
        if let Some(ref val) = self.transit_gateway_multicast_domain_id {
  104    104   
            ser.write_string(
  105    105   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_TRANSIT_GATEWAY_MULTICAST_DOMAIN_ID,
  106    106   
                val,
  107    107   
            )?;
  108    108   
        }
  109    109   
        if let Some(ref val) = self.group_ip_address {
  110    110   
            ser.write_string(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_GROUP_IP_ADDRESS, val)?;
  111    111   
        }
  112    112   
        if let Some(ref val) = self.network_interface_ids {
  113    113   
            ser.write_list(
  114    114   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_NETWORK_INTERFACE_IDS,
  115    115   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  116    116   
                    for item in val {
  117    117   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  118    118   
                    }
  119    119   
                    Ok(())
  120    120   
                },
  121    121   
            )?;
  122    122   
        }
  123    123   
        if let Some(ref val) = self.dry_run {
  124    124   
            ser.write_boolean(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_MEMBER_DRY_RUN, *val)?;
  125    125   
        }
  126    126   
        Ok(())
  127    127   
    }
  128    128   
}
  129    129   
impl DeregisterTransitGatewayMulticastGroupSourcesInput {
  130    130   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  131         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  132         -
        deserializer: &mut D,
         131  +
    pub fn deserialize(
         132  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  133    133   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  134    134   
        #[allow(unused_variables, unused_mut)]
  135    135   
        let mut builder = Self::builder();
  136    136   
        #[allow(
  137    137   
            unused_variables,
  138    138   
            unreachable_code,
  139    139   
            clippy::single_match,
  140    140   
            clippy::match_single_binding,
  141    141   
            clippy::diverging_sub_expression
  142    142   
        )]
  143         -
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_SCHEMA, (), |_, member, deser| {
         143  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESINPUT_SCHEMA, &mut |member, deser| {
  144    144   
            match member.member_index() {
  145    145   
                Some(0) => {
  146    146   
                    builder.transit_gateway_multicast_domain_id = Some(deser.read_string(member)?);
  147    147   
                }
  148    148   
                Some(1) => {
  149    149   
                    builder.group_ip_address = Some(deser.read_string(member)?);
  150    150   
                }
  151    151   
                Some(2) => {
  152         -
                    builder.network_interface_ids = Some({
  153         -
                        let container = if let Some(cap) = deser.container_size() {
  154         -
                            Vec::with_capacity(cap)
  155         -
                        } else {
  156         -
                            Vec::new()
  157         -
                        };
  158         -
                        deser.read_list(member, container, |mut list, deser| {
  159         -
                            list.push(deser.read_string(member)?);
  160         -
                            Ok(list)
  161         -
                        })?
  162         -
                    });
         152  +
                    builder.network_interface_ids = Some(deser.read_string_list(member)?);
  163    153   
                }
  164    154   
                Some(3) => {
  165    155   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  166    156   
                }
  167    157   
                _ => {}
  168    158   
            }
  169    159   
            Ok(())
  170    160   
        })?;
  171    161   
        builder
  172    162   
            .build()
  173    163   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  174    164   
    }
  175    165   
}
         166  +
impl DeregisterTransitGatewayMulticastGroupSourcesInput {
         167  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         168  +
    pub fn deserialize_with_response(
         169  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         170  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         171  +
        _status: u16,
         172  +
        _body: &[u8],
         173  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         174  +
        Self::deserialize(deserializer)
         175  +
    }
         176  +
}
  176    177   
impl DeregisterTransitGatewayMulticastGroupSourcesInput {
  177    178   
    /// Creates a new builder-style object to manufacture [`DeregisterTransitGatewayMulticastGroupSourcesInput`](crate::operation::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesInput).
  178    179   
    pub fn builder(
  179    180   
    ) -> crate::operation::deregister_transit_gateway_multicast_group_sources::builders::DeregisterTransitGatewayMulticastGroupSourcesInputBuilder
  180    181   
    {
  181    182   
        crate::operation::deregister_transit_gateway_multicast_group_sources::builders::DeregisterTransitGatewayMulticastGroupSourcesInputBuilder::default()
  182    183   
    }
  183    184   
}
  184    185   
  185    186   
/// A builder for [`DeregisterTransitGatewayMulticastGroupSourcesInput`](crate::operation::deregister_transit_gateway_multicast_group_sources::DeregisterTransitGatewayMulticastGroupSourcesInput).

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/deregister_transit_gateway_multicast_group_sources/_deregister_transit_gateway_multicast_group_sources_output.rs

@@ -1,1 +101,149 @@
   19     19   
    "DeregisterTransitGatewayMulticastGroupSourcesOutput",
   20     20   
);
   21     21   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_SOURCES: ::aws_smithy_schema::Schema =
   22     22   
    ::aws_smithy_schema::Schema::new_member(
   23     23   
        ::aws_smithy_schema::ShapeId::from_static(
   24     24   
            "com.amazonaws.ec2.synthetic#DeregisterTransitGatewayMulticastGroupSourcesOutput$DeregisteredMulticastGroupSources",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "DeregisterTransitGatewayMulticastGroupSourcesOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "deregistered_multicast_group_sources",
          29  +
        "DeregisteredMulticastGroupSources",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("deregisteredMulticastGroupSources");
          33  +
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          34  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          35  +
    ::aws_smithy_schema::ShapeType::String,
          36  +
    "request_id",
          37  +
    1,
          38  +
)
          39  +
.with_http_header("x-amzn-requestid");
   33     40   
static DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_SOURCES],
          43  +
    &[
          44  +
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_SOURCES,
          45  +
        &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl DeregisterTransitGatewayMulticastGroupSourcesOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for DeregisterTransitGatewayMulticastGroupSourcesOutput {
   43     53   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   44     54   
    fn serialize_members(
   45     55   
        &self,
   46     56   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   47     57   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   48     58   
        if let Some(ref val) = self.deregistered_multicast_group_sources {
   49     59   
            ser.write_struct(
   50     60   
                &DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_MEMBER_DEREGISTERED_MULTICAST_GROUP_SOURCES,
   51     61   
                val,
   52     62   
            )?;
   53     63   
        }
   54     64   
        Ok(())
   55     65   
    }
   56     66   
}
   57     67   
impl DeregisterTransitGatewayMulticastGroupSourcesOutput {
   58     68   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   59         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   60         -
        deserializer: &mut D,
          69  +
    pub fn deserialize(
          70  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          71  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          72  +
        #[allow(unused_variables, unused_mut)]
          73  +
        let mut builder = Self::builder();
          74  +
        #[allow(
          75  +
            unused_variables,
          76  +
            unreachable_code,
          77  +
            clippy::single_match,
          78  +
            clippy::match_single_binding,
          79  +
            clippy::diverging_sub_expression
          80  +
        )]
          81  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA, &mut |member, deser| {
          82  +
            match member.member_index() {
          83  +
                Some(0) => {
          84  +
                    builder.deregistered_multicast_group_sources =
          85  +
                        Some(crate::types::TransitGatewayMulticastDeregisteredGroupSources::deserialize(deser)?);
          86  +
                }
          87  +
                Some(1) => {
          88  +
                    builder._request_id = Some(deser.read_string(member)?);
          89  +
                }
          90  +
                _ => {}
          91  +
            }
          92  +
            Ok(())
          93  +
        })?;
          94  +
        Ok(builder.build())
          95  +
    }
          96  +
}
          97  +
impl DeregisterTransitGatewayMulticastGroupSourcesOutput {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          99  +
    /// Header-bound members are read directly from headers, avoiding runtime
         100  +
    /// member iteration overhead. Body members are read via the deserializer.
         101  +
    pub fn deserialize_with_response(
         102  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         103  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         104  +
        _status: u16,
         105  +
        _body: &[u8],
   61    106   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   62    107   
        #[allow(unused_variables, unused_mut)]
   63    108   
        let mut builder = Self::builder();
         109  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         110  +
            builder._request_id = Some(val.to_string());
         111  +
        }
   64    112   
        #[allow(
   65    113   
            unused_variables,
   66    114   
            unreachable_code,
   67    115   
            clippy::single_match,
   68    116   
            clippy::match_single_binding,
   69    117   
            clippy::diverging_sub_expression
   70    118   
        )]
   71         -
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA, (), |_, member, deser| {
         119  +
        deserializer.read_struct(&DEREGISTERTRANSITGATEWAYMULTICASTGROUPSOURCESOUTPUT_SCHEMA, &mut |member, deser| {
   72    120   
            match member.member_index() {
   73    121   
                Some(0) => {
   74    122   
                    builder.deregistered_multicast_group_sources =
   75    123   
                        Some(crate::types::TransitGatewayMulticastDeregisteredGroupSources::deserialize(deser)?);
   76    124   
                }
   77    125   
                _ => {}
   78    126   
            }
   79    127   
            Ok(())
   80    128   
        })?;
   81    129   
        Ok(builder.build())

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_account_attributes.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 `DescribeAccountAttributes`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribeAccountAttributes;
    6      6   
impl DescribeAccountAttributes {
    7      7   
    /// Creates a new `DescribeAccountAttributes`
    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::describe_account_attributes::DescribeAccountAttributesInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::describe_account_attributes::DescribeAccountAttributesOutput::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::describe_account_attributes::DescribeAccountAttributesInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::describe_account_attributes::DescribeAccountAttributesOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::describe_account_attributes::DescribeAccountAttributesError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -121,127 +180,187 @@
  141    147   
        ::std::borrow::Cow::Owned(rcb)
  142    148   
    }
  143    149   
}
  144    150   
  145    151   
#[derive(Debug)]
  146    152   
struct DescribeAccountAttributesResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribeAccountAttributesResponseDeserializer {
  148    154   
    fn deserialize_nonstreaming(
  149    155   
        &self,
  150    156   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         157  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    158   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    159   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    160   
        let headers = response.headers();
  154    161   
        let body = response.body().bytes().expect("body loaded");
  155    162   
        #[allow(unused_mut)]
  156    163   
        let mut force_error = false;
  157    164   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    165   
        let parse_result = if !success && status != 200 || force_error {
  159    166   
            crate::protocol_serde::shape_describe_account_attributes::de_describe_account_attributes_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_account_attributes/_describe_account_attributes_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_account_attributes/_describe_account_attributes_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_address_transfers.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 `DescribeAddressTransfers`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct DescribeAddressTransfers;
    6      6   
impl DescribeAddressTransfers {
    7      7   
    /// Creates a new `DescribeAddressTransfers`
    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::describe_address_transfers::DescribeAddressTransfersInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::describe_address_transfers::DescribeAddressTransfersOutput::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::describe_address_transfers::DescribeAddressTransfersInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::describe_address_transfers::DescribeAddressTransfersOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::describe_address_transfers::DescribeAddressTransfersError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -121,127 +180,187 @@
  141    147   
        ::std::borrow::Cow::Owned(rcb)
  142    148   
    }
  143    149   
}
  144    150   
  145    151   
#[derive(Debug)]
  146    152   
struct DescribeAddressTransfersResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribeAddressTransfersResponseDeserializer {
  148    154   
    fn deserialize_nonstreaming(
  149    155   
        &self,
  150    156   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         157  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    158   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    159   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    160   
        let headers = response.headers();
  154    161   
        let body = response.body().bytes().expect("body loaded");
  155    162   
        #[allow(unused_mut)]
  156    163   
        let mut force_error = false;
  157    164   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    165   
        let parse_result = if !success && status != 200 || force_error {
  159    166   
            crate::protocol_serde::shape_describe_address_transfers::de_describe_address_transfers_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/describe_address_transfers/_describe_address_transfers_input.rs

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