AWS SDK

AWS SDK

rev. 163d4d6410694aaf071424777ecbecd050925f36

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_availability_zone_group/_modify_availability_zone_group_output.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_capacity_reservation.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 `ModifyCapacityReservation`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ModifyCapacityReservation;
    6      6   
impl ModifyCapacityReservation {
    7      7   
    /// Creates a new `ModifyCapacityReservation`
    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::modify_capacity_reservation::ModifyCapacityReservationInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::modify_capacity_reservation::ModifyCapacityReservationOutput::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::modify_capacity_reservation::ModifyCapacityReservationInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::modify_capacity_reservation::ModifyCapacityReservationOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::modify_capacity_reservation::ModifyCapacityReservationError,
   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 ModifyCapacityReservationResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ModifyCapacityReservationResponseDeserializer {
  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_modify_capacity_reservation::de_modify_capacity_reservation_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_capacity_reservation/_modify_capacity_reservation_input.rs

@@ -57,57 +289,301 @@
   77     77   
    "com.amazonaws.ec2.synthetic",
   78     78   
    "ModifyCapacityReservationInput",
   79     79   
);
   80     80   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_CAPACITY_RESERVATION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$CapacityReservationId",
   83     83   
        "com.amazonaws.ec2.synthetic",
   84     84   
        "ModifyCapacityReservationInput",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "capacity_reservation_id",
          87  +
    "CapacityReservationId",
   88     88   
    0,
   89     89   
);
   90     90   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$InstanceCount",
   93     93   
        "com.amazonaws.ec2.synthetic",
   94     94   
        "ModifyCapacityReservationInput",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Integer,
   97         -
    "instance_count",
          97  +
    "InstanceCount",
   98     98   
    1,
   99     99   
);
  100    100   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$EndDate",
  103    103   
        "com.amazonaws.ec2.synthetic",
  104    104   
        "ModifyCapacityReservationInput",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::Timestamp,
  107         -
    "end_date",
         107  +
    "EndDate",
  108    108   
    2,
  109    109   
);
  110    110   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static(
  112    112   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$EndDateType",
  113    113   
        "com.amazonaws.ec2.synthetic",
  114    114   
        "ModifyCapacityReservationInput",
  115    115   
    ),
  116    116   
    ::aws_smithy_schema::ShapeType::String,
  117         -
    "end_date_type",
         117  +
    "EndDateType",
  118    118   
    3,
  119    119   
);
  120    120   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ACCEPT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  121    121   
    ::aws_smithy_schema::ShapeId::from_static(
  122    122   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$Accept",
  123    123   
        "com.amazonaws.ec2.synthetic",
  124    124   
        "ModifyCapacityReservationInput",
  125    125   
    ),
  126    126   
    ::aws_smithy_schema::ShapeType::Boolean,
  127         -
    "accept",
         127  +
    "Accept",
  128    128   
    4,
  129    129   
);
  130    130   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$DryRun",
  133    133   
        "com.amazonaws.ec2.synthetic",
  134    134   
        "ModifyCapacityReservationInput",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::Boolean,
  137         -
    "dry_run",
         137  +
    "DryRun",
  138    138   
    5,
  139    139   
);
  140    140   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ADDITIONAL_INFO: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$AdditionalInfo",
  143    143   
        "com.amazonaws.ec2.synthetic",
  144    144   
        "ModifyCapacityReservationInput",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "additional_info",
         147  +
    "AdditionalInfo",
  148    148   
    6,
  149    149   
);
  150    150   
static MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_MATCH_CRITERIA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.ec2.synthetic#ModifyCapacityReservationInput$InstanceMatchCriteria",
  153    153   
        "com.amazonaws.ec2.synthetic",
  154    154   
        "ModifyCapacityReservationInput",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "instance_match_criteria",
         157  +
    "InstanceMatchCriteria",
  158    158   
    7,
  159    159   
);
  160    160   
static MODIFYCAPACITYRESERVATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  161    161   
    MODIFYCAPACITYRESERVATIONINPUT_SCHEMA_ID,
  162    162   
    ::aws_smithy_schema::ShapeType::Structure,
  163    163   
    &[
  164    164   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_CAPACITY_RESERVATION_ID,
  165    165   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_COUNT,
  166    166   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE,
  167    167   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE_TYPE,
  168    168   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ACCEPT,
  169    169   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN,
  170    170   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ADDITIONAL_INFO,
  171    171   
        &MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_MATCH_CRITERIA,
  172    172   
    ],
  173    173   
);
  174    174   
impl ModifyCapacityReservationInput {
  175    175   
    /// The schema for this shape.
  176    176   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYCAPACITYRESERVATIONINPUT_SCHEMA;
  177    177   
}
  178    178   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyCapacityReservationInput {
  179    179   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  180    180   
    fn serialize_members(
  181    181   
        &self,
  182    182   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  183    183   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  184    184   
        if let Some(ref val) = self.capacity_reservation_id {
  185    185   
            ser.write_string(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_CAPACITY_RESERVATION_ID, val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.instance_count {
  188    188   
            ser.write_integer(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_COUNT, *val)?;
  189    189   
        }
  190    190   
        if let Some(ref val) = self.end_date {
  191    191   
            ser.write_timestamp(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE, val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.end_date_type {
  194    194   
            ser.write_string(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_END_DATE_TYPE, val.as_str())?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.accept {
  197    197   
            ser.write_boolean(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ACCEPT, *val)?;
  198    198   
        }
  199    199   
        if let Some(ref val) = self.dry_run {
  200    200   
            ser.write_boolean(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_DRY_RUN, *val)?;
  201    201   
        }
  202    202   
        if let Some(ref val) = self.additional_info {
  203    203   
            ser.write_string(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_ADDITIONAL_INFO, val)?;
  204    204   
        }
  205    205   
        if let Some(ref val) = self.instance_match_criteria {
  206    206   
            ser.write_string(&MODIFYCAPACITYRESERVATIONINPUT_MEMBER_INSTANCE_MATCH_CRITERIA, val.as_str())?;
  207    207   
        }
  208    208   
        Ok(())
  209    209   
    }
  210    210   
}
  211    211   
impl ModifyCapacityReservationInput {
  212    212   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  213         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  214         -
        deserializer: &mut D,
         213  +
    pub fn deserialize(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  215    215   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  216    216   
        #[allow(unused_variables, unused_mut)]
  217    217   
        let mut builder = Self::builder();
  218    218   
        #[allow(
  219    219   
            unused_variables,
  220    220   
            unreachable_code,
  221    221   
            clippy::single_match,
  222    222   
            clippy::match_single_binding,
  223    223   
            clippy::diverging_sub_expression
  224    224   
        )]
  225         -
        deserializer.read_struct(&MODIFYCAPACITYRESERVATIONINPUT_SCHEMA, (), |_, member, deser| {
         225  +
        deserializer.read_struct(&MODIFYCAPACITYRESERVATIONINPUT_SCHEMA, &mut |member, deser| {
  226    226   
            match member.member_index() {
  227    227   
                Some(0) => {
  228    228   
                    builder.capacity_reservation_id = Some(deser.read_string(member)?);
  229    229   
                }
  230    230   
                Some(1) => {
  231    231   
                    builder.instance_count = Some(deser.read_integer(member)?);
  232    232   
                }
  233    233   
                Some(2) => {
  234    234   
                    builder.end_date = Some(deser.read_timestamp(member)?);
  235    235   
                }
  236    236   
                Some(3) => {
  237    237   
                    builder.end_date_type = Some(crate::types::EndDateType::from(deser.read_string(member)?.as_str()));
  238    238   
                }
  239    239   
                Some(4) => {
  240    240   
                    builder.accept = Some(deser.read_boolean(member)?);
  241    241   
                }
  242    242   
                Some(5) => {
  243    243   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  244    244   
                }
  245    245   
                Some(6) => {
  246    246   
                    builder.additional_info = Some(deser.read_string(member)?);
  247    247   
                }
  248    248   
                Some(7) => {
  249    249   
                    builder.instance_match_criteria = Some(crate::types::InstanceMatchCriteria::from(deser.read_string(member)?.as_str()));
  250    250   
                }
  251    251   
                _ => {}
  252    252   
            }
  253    253   
            Ok(())
  254    254   
        })?;
         255  +
        builder.capacity_reservation_id = builder.capacity_reservation_id.or(Some(String::new()));
  255    256   
        builder
  256    257   
            .build()
  257    258   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  258    259   
    }
  259    260   
}
         261  +
impl ModifyCapacityReservationInput {
         262  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         263  +
    pub fn deserialize_with_response(
         264  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         265  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         266  +
        _status: u16,
         267  +
        _body: &[u8],
         268  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         269  +
        Self::deserialize(deserializer)
         270  +
    }
         271  +
}
  260    272   
impl ModifyCapacityReservationInput {
  261    273   
    /// Creates a new builder-style object to manufacture [`ModifyCapacityReservationInput`](crate::operation::modify_capacity_reservation::ModifyCapacityReservationInput).
  262    274   
    pub fn builder() -> crate::operation::modify_capacity_reservation::builders::ModifyCapacityReservationInputBuilder {
  263    275   
        crate::operation::modify_capacity_reservation::builders::ModifyCapacityReservationInputBuilder::default()
  264    276   
    }
  265    277   
}
  266    278   
  267    279   
/// A builder for [`ModifyCapacityReservationInput`](crate::operation::modify_capacity_reservation::ModifyCapacityReservationInput).
  268    280   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  269    281   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_capacity_reservation/_modify_capacity_reservation_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_capacity_reservation_fleet/_modify_capacity_reservation_fleet_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_capacity_reservation_fleet/_modify_capacity_reservation_fleet_output.rs

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

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

@@ -1,1 +40,45 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `ModifyClientVpnEndpoint`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ModifyClientVpnEndpoint;
    6      6   
impl ModifyClientVpnEndpoint {
    7      7   
    /// Creates a new `ModifyClientVpnEndpoint`
    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 = crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          15  +
        crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointOutput::SCHEMA;
   11     16   
    pub(crate) async fn orchestrate(
   12     17   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     18   
        input: crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointInput,
   14     19   
    ) -> ::std::result::Result<
   15     20   
        crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointOutput,
   16     21   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     22   
            crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointError,
   18     23   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     24   
        >,
   20     25   
    > {
@@ -121,126 +180,186 @@
  141    146   
        ::std::borrow::Cow::Owned(rcb)
  142    147   
    }
  143    148   
}
  144    149   
  145    150   
#[derive(Debug)]
  146    151   
struct ModifyClientVpnEndpointResponseDeserializer;
  147    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ModifyClientVpnEndpointResponseDeserializer {
  148    153   
    fn deserialize_nonstreaming(
  149    154   
        &self,
  150    155   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         156  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  151    157   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  152    158   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  153    159   
        let headers = response.headers();
  154    160   
        let body = response.body().bytes().expect("body loaded");
  155    161   
        #[allow(unused_mut)]
  156    162   
        let mut force_error = false;
  157    163   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  158    164   
        let parse_result = if !success && status != 200 || force_error {
  159    165   
            crate::protocol_serde::shape_modify_client_vpn_endpoint::de_modify_client_vpn_endpoint_http_error(status, headers, body)
  160    166   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_client_vpn_endpoint/_modify_client_vpn_endpoint_input.rs

@@ -123,123 +334,334 @@
  143    143   
    "com.amazonaws.ec2.synthetic",
  144    144   
    "ModifyClientVpnEndpointInput",
  145    145   
);
  146    146   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_VPN_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ClientVpnEndpointId",
  149    149   
        "com.amazonaws.ec2.synthetic",
  150    150   
        "ModifyClientVpnEndpointInput",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "client_vpn_endpoint_id",
         153  +
    "ClientVpnEndpointId",
  154    154   
    0,
  155    155   
);
  156    156   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SERVER_CERTIFICATE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ServerCertificateArn",
  159    159   
        "com.amazonaws.ec2.synthetic",
  160    160   
        "ModifyClientVpnEndpointInput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::String,
  163         -
    "server_certificate_arn",
         163  +
    "ServerCertificateArn",
  164    164   
    1,
  165    165   
);
  166    166   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CONNECTION_LOG_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ConnectionLogOptions",
  169    169   
        "com.amazonaws.ec2.synthetic",
  170    170   
        "ModifyClientVpnEndpointInput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::Structure,
  173         -
    "connection_log_options",
         173  +
    "ConnectionLogOptions",
  174    174   
    2,
  175    175   
);
  176    176   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DNS_SERVERS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  177    177   
    ::aws_smithy_schema::ShapeId::from_static(
  178    178   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$DnsServers",
  179    179   
        "com.amazonaws.ec2.synthetic",
  180    180   
        "ModifyClientVpnEndpointInput",
  181    181   
    ),
  182    182   
    ::aws_smithy_schema::ShapeType::Structure,
  183         -
    "dns_servers",
         183  +
    "DnsServers",
  184    184   
    3,
  185    185   
);
  186    186   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_VPN_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  187    187   
    ::aws_smithy_schema::ShapeId::from_static(
  188    188   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$VpnPort",
  189    189   
        "com.amazonaws.ec2.synthetic",
  190    190   
        "ModifyClientVpnEndpointInput",
  191    191   
    ),
  192    192   
    ::aws_smithy_schema::ShapeType::Integer,
  193         -
    "vpn_port",
         193  +
    "VpnPort",
  194    194   
    4,
  195    195   
);
  196    196   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static(
  198    198   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$Description",
  199    199   
        "com.amazonaws.ec2.synthetic",
  200    200   
        "ModifyClientVpnEndpointInput",
  201    201   
    ),
  202    202   
    ::aws_smithy_schema::ShapeType::String,
  203         -
    "description",
         203  +
    "Description",
  204    204   
    5,
  205    205   
);
  206    206   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SPLIT_TUNNEL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  207    207   
    ::aws_smithy_schema::ShapeId::from_static(
  208    208   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$SplitTunnel",
  209    209   
        "com.amazonaws.ec2.synthetic",
  210    210   
        "ModifyClientVpnEndpointInput",
  211    211   
    ),
  212    212   
    ::aws_smithy_schema::ShapeType::Boolean,
  213         -
    "split_tunnel",
         213  +
    "SplitTunnel",
  214    214   
    6,
  215    215   
);
  216    216   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  217    217   
    ::aws_smithy_schema::ShapeId::from_static(
  218    218   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$DryRun",
  219    219   
        "com.amazonaws.ec2.synthetic",
  220    220   
        "ModifyClientVpnEndpointInput",
  221    221   
    ),
  222    222   
    ::aws_smithy_schema::ShapeType::Boolean,
  223         -
    "dry_run",
         223  +
    "DryRun",
  224    224   
    7,
  225    225   
);
  226    226   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SECURITY_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  227    227   
    ::aws_smithy_schema::ShapeId::from_static(
  228    228   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$SecurityGroupIds",
  229    229   
        "com.amazonaws.ec2.synthetic",
  230    230   
        "ModifyClientVpnEndpointInput",
  231    231   
    ),
  232    232   
    ::aws_smithy_schema::ShapeType::List,
  233         -
    "security_group_ids",
         233  +
    "SecurityGroupIds",
  234    234   
    8,
  235    235   
)
  236    236   
.with_xml_name("SecurityGroupId");
  237    237   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  238    238   
    ::aws_smithy_schema::ShapeId::from_static(
  239    239   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$VpcId",
  240    240   
        "com.amazonaws.ec2.synthetic",
  241    241   
        "ModifyClientVpnEndpointInput",
  242    242   
    ),
  243    243   
    ::aws_smithy_schema::ShapeType::String,
  244         -
    "vpc_id",
         244  +
    "VpcId",
  245    245   
    9,
  246    246   
);
  247    247   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SELF_SERVICE_PORTAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  248    248   
    ::aws_smithy_schema::ShapeId::from_static(
  249    249   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$SelfServicePortal",
  250    250   
        "com.amazonaws.ec2.synthetic",
  251    251   
        "ModifyClientVpnEndpointInput",
  252    252   
    ),
  253    253   
    ::aws_smithy_schema::ShapeType::String,
  254         -
    "self_service_portal",
         254  +
    "SelfServicePortal",
  255    255   
    10,
  256    256   
);
  257    257   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_CONNECT_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  258    258   
    ::aws_smithy_schema::ShapeId::from_static(
  259    259   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ClientConnectOptions",
  260    260   
        "com.amazonaws.ec2.synthetic",
  261    261   
        "ModifyClientVpnEndpointInput",
  262    262   
    ),
  263    263   
    ::aws_smithy_schema::ShapeType::Structure,
  264         -
    "client_connect_options",
         264  +
    "ClientConnectOptions",
  265    265   
    11,
  266    266   
);
  267    267   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SESSION_TIMEOUT_HOURS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  268    268   
    ::aws_smithy_schema::ShapeId::from_static(
  269    269   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$SessionTimeoutHours",
  270    270   
        "com.amazonaws.ec2.synthetic",
  271    271   
        "ModifyClientVpnEndpointInput",
  272    272   
    ),
  273    273   
    ::aws_smithy_schema::ShapeType::Integer,
  274         -
    "session_timeout_hours",
         274  +
    "SessionTimeoutHours",
  275    275   
    12,
  276    276   
);
  277    277   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_LOGIN_BANNER_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  278    278   
    ::aws_smithy_schema::ShapeId::from_static(
  279    279   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ClientLoginBannerOptions",
  280    280   
        "com.amazonaws.ec2.synthetic",
  281    281   
        "ModifyClientVpnEndpointInput",
  282    282   
    ),
  283    283   
    ::aws_smithy_schema::ShapeType::Structure,
  284         -
    "client_login_banner_options",
         284  +
    "ClientLoginBannerOptions",
  285    285   
    13,
  286    286   
);
  287    287   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_ROUTE_ENFORCEMENT_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  288    288   
    ::aws_smithy_schema::ShapeId::from_static(
  289    289   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$ClientRouteEnforcementOptions",
  290    290   
        "com.amazonaws.ec2.synthetic",
  291    291   
        "ModifyClientVpnEndpointInput",
  292    292   
    ),
  293    293   
    ::aws_smithy_schema::ShapeType::Structure,
  294         -
    "client_route_enforcement_options",
         294  +
    "ClientRouteEnforcementOptions",
  295    295   
    14,
  296    296   
);
  297    297   
static MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DISCONNECT_ON_SESSION_TIMEOUT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  298    298   
    ::aws_smithy_schema::ShapeId::from_static(
  299    299   
        "com.amazonaws.ec2.synthetic#ModifyClientVpnEndpointInput$DisconnectOnSessionTimeout",
  300    300   
        "com.amazonaws.ec2.synthetic",
  301    301   
        "ModifyClientVpnEndpointInput",
  302    302   
    ),
  303    303   
    ::aws_smithy_schema::ShapeType::Boolean,
  304         -
    "disconnect_on_session_timeout",
         304  +
    "DisconnectOnSessionTimeout",
  305    305   
    15,
  306    306   
);
  307    307   
static MODIFYCLIENTVPNENDPOINTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  308    308   
    MODIFYCLIENTVPNENDPOINTINPUT_SCHEMA_ID,
  309    309   
    ::aws_smithy_schema::ShapeType::Structure,
  310    310   
    &[
  311    311   
        &MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_VPN_ENDPOINT_ID,
  312    312   
        &MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_SERVER_CERTIFICATE_ARN,
  313    313   
        &MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CONNECTION_LOG_OPTIONS,
  314    314   
        &MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DNS_SERVERS,
@@ -370,370 +510,512 @@
  390    390   
            ser.write_struct(&MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_CLIENT_ROUTE_ENFORCEMENT_OPTIONS, val)?;
  391    391   
        }
  392    392   
        if let Some(ref val) = self.disconnect_on_session_timeout {
  393    393   
            ser.write_boolean(&MODIFYCLIENTVPNENDPOINTINPUT_MEMBER_DISCONNECT_ON_SESSION_TIMEOUT, *val)?;
  394    394   
        }
  395    395   
        Ok(())
  396    396   
    }
  397    397   
}
  398    398   
impl ModifyClientVpnEndpointInput {
  399    399   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  400         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  401         -
        deserializer: &mut D,
         400  +
    pub fn deserialize(
         401  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  402    402   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  403    403   
        #[allow(unused_variables, unused_mut)]
  404    404   
        let mut builder = Self::builder();
  405    405   
        #[allow(
  406    406   
            unused_variables,
  407    407   
            unreachable_code,
  408    408   
            clippy::single_match,
  409    409   
            clippy::match_single_binding,
  410    410   
            clippy::diverging_sub_expression
  411    411   
        )]
  412         -
        deserializer.read_struct(&MODIFYCLIENTVPNENDPOINTINPUT_SCHEMA, (), |_, member, deser| {
         412  +
        deserializer.read_struct(&MODIFYCLIENTVPNENDPOINTINPUT_SCHEMA, &mut |member, deser| {
  413    413   
            match member.member_index() {
  414    414   
                Some(0) => {
  415    415   
                    builder.client_vpn_endpoint_id = Some(deser.read_string(member)?);
  416    416   
                }
  417    417   
                Some(1) => {
  418    418   
                    builder.server_certificate_arn = Some(deser.read_string(member)?);
  419    419   
                }
  420    420   
                Some(2) => {
  421    421   
                    builder.connection_log_options = Some(crate::types::ConnectionLogOptions::deserialize(deser)?);
  422    422   
                }
  423    423   
                Some(3) => {
  424    424   
                    builder.dns_servers = Some(crate::types::DnsServersOptionsModifyStructure::deserialize(deser)?);
  425    425   
                }
  426    426   
                Some(4) => {
  427    427   
                    builder.vpn_port = Some(deser.read_integer(member)?);
  428    428   
                }
  429    429   
                Some(5) => {
  430    430   
                    builder.description = Some(deser.read_string(member)?);
  431    431   
                }
  432    432   
                Some(6) => {
  433    433   
                    builder.split_tunnel = Some(deser.read_boolean(member)?);
  434    434   
                }
  435    435   
                Some(7) => {
  436    436   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  437    437   
                }
  438    438   
                Some(8) => {
  439         -
                    builder.security_group_ids = Some({
  440         -
                        let container = if let Some(cap) = deser.container_size() {
  441         -
                            Vec::with_capacity(cap)
  442         -
                        } else {
  443         -
                            Vec::new()
  444         -
                        };
  445         -
                        deser.read_list(member, container, |mut list, deser| {
  446         -
                            list.push(deser.read_string(member)?);
  447         -
                            Ok(list)
  448         -
                        })?
  449         -
                    });
         439  +
                    builder.security_group_ids = Some(deser.read_string_list(member)?);
  450    440   
                }
  451    441   
                Some(9) => {
  452    442   
                    builder.vpc_id = Some(deser.read_string(member)?);
  453    443   
                }
  454    444   
                Some(10) => {
  455    445   
                    builder.self_service_portal = Some(crate::types::SelfServicePortal::from(deser.read_string(member)?.as_str()));
  456    446   
                }
  457    447   
                Some(11) => {
  458    448   
                    builder.client_connect_options = Some(crate::types::ClientConnectOptions::deserialize(deser)?);
  459    449   
                }
  460    450   
                Some(12) => {
  461    451   
                    builder.session_timeout_hours = Some(deser.read_integer(member)?);
  462    452   
                }
  463    453   
                Some(13) => {
  464    454   
                    builder.client_login_banner_options = Some(crate::types::ClientLoginBannerOptions::deserialize(deser)?);
  465    455   
                }
  466    456   
                Some(14) => {
  467    457   
                    builder.client_route_enforcement_options = Some(crate::types::ClientRouteEnforcementOptions::deserialize(deser)?);
  468    458   
                }
  469    459   
                Some(15) => {
  470    460   
                    builder.disconnect_on_session_timeout = Some(deser.read_boolean(member)?);
  471    461   
                }
  472    462   
                _ => {}
  473    463   
            }
  474    464   
            Ok(())
  475    465   
        })?;
         466  +
        builder.client_vpn_endpoint_id = builder.client_vpn_endpoint_id.or(Some(String::new()));
  476    467   
        builder
  477    468   
            .build()
  478    469   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  479    470   
    }
  480    471   
}
         472  +
impl ModifyClientVpnEndpointInput {
         473  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         474  +
    pub fn deserialize_with_response(
         475  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         476  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         477  +
        _status: u16,
         478  +
        _body: &[u8],
         479  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         480  +
        Self::deserialize(deserializer)
         481  +
    }
         482  +
}
  481    483   
impl ModifyClientVpnEndpointInput {
  482    484   
    /// Creates a new builder-style object to manufacture [`ModifyClientVpnEndpointInput`](crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointInput).
  483    485   
    pub fn builder() -> crate::operation::modify_client_vpn_endpoint::builders::ModifyClientVpnEndpointInputBuilder {
  484    486   
        crate::operation::modify_client_vpn_endpoint::builders::ModifyClientVpnEndpointInputBuilder::default()
  485    487   
    }
  486    488   
}
  487    489   
  488    490   
/// A builder for [`ModifyClientVpnEndpointInput`](crate::operation::modify_client_vpn_endpoint::ModifyClientVpnEndpointInput).
  489    491   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  490    492   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_client_vpn_endpoint/_modify_client_vpn_endpoint_output.rs

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

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_default_credit_specification/_modify_default_credit_specification_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_default_credit_specification/_modify_default_credit_specification_output.rs

@@ -1,1 +98,145 @@
   19     19   
    "ModifyDefaultCreditSpecificationOutput",
   20     20   
);
   21     21   
static MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_MEMBER_INSTANCE_FAMILY_CREDIT_SPECIFICATION: ::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#ModifyDefaultCreditSpecificationOutput$InstanceFamilyCreditSpecification",
   25     25   
            "com.amazonaws.ec2.synthetic",
   26     26   
            "ModifyDefaultCreditSpecificationOutput",
   27     27   
        ),
   28     28   
        ::aws_smithy_schema::ShapeType::Structure,
   29         -
        "instance_family_credit_specification",
          29  +
        "InstanceFamilyCreditSpecification",
   30     30   
        0,
   31     31   
    )
   32     32   
    .with_xml_name("instanceFamilyCreditSpecification");
          33  +
static MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_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 MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   34     41   
    MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA_ID,
   35     42   
    ::aws_smithy_schema::ShapeType::Structure,
   36         -
    &[&MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_MEMBER_INSTANCE_FAMILY_CREDIT_SPECIFICATION],
          43  +
    &[
          44  +
        &MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_MEMBER_INSTANCE_FAMILY_CREDIT_SPECIFICATION,
          45  +
        &MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_MEMBER__REQUEST_ID,
          46  +
    ],
   37     47   
);
   38     48   
impl ModifyDefaultCreditSpecificationOutput {
   39     49   
    /// The schema for this shape.
   40     50   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA;
   41     51   
}
   42     52   
impl ::aws_smithy_schema::serde::SerializableStruct for ModifyDefaultCreditSpecificationOutput {
   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_family_credit_specification {
   49     59   
            ser.write_struct(&MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_MEMBER_INSTANCE_FAMILY_CREDIT_SPECIFICATION, val)?;
   50     60   
        }
   51     61   
        Ok(())
   52     62   
    }
   53     63   
}
   54     64   
impl ModifyDefaultCreditSpecificationOutput {
   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(&MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA, &mut |member, deser| {
          79  +
            match member.member_index() {
          80  +
                Some(0) => {
          81  +
                    builder.instance_family_credit_specification = Some(crate::types::InstanceFamilyCreditSpecification::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 ModifyDefaultCreditSpecificationOutput {
          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(&MODIFYDEFAULTCREDITSPECIFICATIONOUTPUT_SCHEMA, &mut |member, deser| {
   69    116   
            match member.member_index() {
   70    117   
                Some(0) => {
   71    118   
                    builder.instance_family_credit_specification = Some(crate::types::InstanceFamilyCreditSpecification::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/modify_ebs_default_kms_key_id.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 `ModifyEbsDefaultKmsKeyId`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct ModifyEbsDefaultKmsKeyId;
    6      6   
impl ModifyEbsDefaultKmsKeyId {
    7      7   
    /// Creates a new `ModifyEbsDefaultKmsKeyId`
    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::modify_ebs_default_kms_key_id::ModifyEbsDefaultKmsKeyIdInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::modify_ebs_default_kms_key_id::ModifyEbsDefaultKmsKeyIdOutput::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::modify_ebs_default_kms_key_id::ModifyEbsDefaultKmsKeyIdInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::modify_ebs_default_kms_key_id::ModifyEbsDefaultKmsKeyIdOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::modify_ebs_default_kms_key_id::ModifyEbsDefaultKmsKeyIdError,
   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 ModifyEbsDefaultKmsKeyIdResponseDeserializer;
  147    153   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for ModifyEbsDefaultKmsKeyIdResponseDeserializer {
  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_modify_ebs_default_kms_key_id::de_modify_ebs_default_kms_key_id_http_error(status, headers, body)
  160    167   
        } else {

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_ebs_default_kms_key_id/_modify_ebs_default_kms_key_id_input.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/operation/modify_ebs_default_kms_key_id/_modify_ebs_default_kms_key_id_output.rs

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