AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_resource_statement_request.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_resource_type_option.rs

@@ -55,55 +199,200 @@
   75     75   
}
   76     76   
static RESOURCETYPEOPTION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   77     77   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#ResourceTypeOption", "com.amazonaws.ec2", "ResourceTypeOption");
   78     78   
static RESOURCETYPEOPTION_MEMBER_OPTION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.ec2#ResourceTypeOption$OptionName",
   81     81   
        "com.amazonaws.ec2",
   82     82   
        "ResourceTypeOption",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "option_name",
          85  +
    "OptionName",
   86     86   
    0,
   87     87   
);
   88     88   
static RESOURCETYPEOPTION_MEMBER_OPTION_VALUES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#ResourceTypeOption$OptionValues",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "ResourceTypeOption",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::List,
   95         -
    "option_values",
          95  +
    "OptionValues",
   96     96   
    1,
   97     97   
)
   98     98   
.with_xml_name("OptionValue");
   99     99   
static RESOURCETYPEOPTION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    100   
    RESOURCETYPEOPTION_SCHEMA_ID,
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102    102   
    &[&RESOURCETYPEOPTION_MEMBER_OPTION_NAME, &RESOURCETYPEOPTION_MEMBER_OPTION_VALUES],
  103    103   
);
  104    104   
impl ResourceTypeOption {
  105    105   
    /// The schema for this shape.
  106    106   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCETYPEOPTION_SCHEMA;
  107    107   
}
  108    108   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceTypeOption {
  109    109   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  110    110   
    fn serialize_members(
  111    111   
        &self,
  112    112   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  113    113   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  114    114   
        if let Some(ref val) = self.option_name {
  115    115   
            ser.write_string(&RESOURCETYPEOPTION_MEMBER_OPTION_NAME, val.as_str())?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.option_values {
  118    118   
            ser.write_list(
  119    119   
                &RESOURCETYPEOPTION_MEMBER_OPTION_VALUES,
  120    120   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  121    121   
                    for item in val {
  122    122   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  123    123   
                    }
  124    124   
                    Ok(())
  125    125   
                },
  126    126   
            )?;
  127    127   
        }
  128    128   
        Ok(())
  129    129   
    }
  130    130   
}
  131    131   
impl ResourceTypeOption {
  132    132   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  133         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  134         -
        deserializer: &mut D,
         133  +
    pub fn deserialize(
         134  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  135    135   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  136    136   
        #[allow(unused_variables, unused_mut)]
  137    137   
        let mut builder = Self::builder();
  138    138   
        #[allow(
  139    139   
            unused_variables,
  140    140   
            unreachable_code,
  141    141   
            clippy::single_match,
  142    142   
            clippy::match_single_binding,
  143    143   
            clippy::diverging_sub_expression
  144    144   
        )]
  145         -
        deserializer.read_struct(&RESOURCETYPEOPTION_SCHEMA, (), |_, member, deser| {
         145  +
        deserializer.read_struct(&RESOURCETYPEOPTION_SCHEMA, &mut |member, deser| {
  146    146   
            match member.member_index() {
  147    147   
                Some(0) => {
  148    148   
                    builder.option_name = Some(crate::types::ImageReferenceOptionName::from(deser.read_string(member)?.as_str()));
  149    149   
                }
  150    150   
                Some(1) => {
  151         -
                    builder.option_values = Some({
  152         -
                        let container = if let Some(cap) = deser.container_size() {
  153         -
                            Vec::with_capacity(cap)
  154         -
                        } else {
  155         -
                            Vec::new()
  156         -
                        };
  157         -
                        deser.read_list(member, container, |mut list, deser| {
  158         -
                            list.push(deser.read_string(member)?);
  159         -
                            Ok(list)
  160         -
                        })?
  161         -
                    });
         151  +
                    builder.option_values = Some(deser.read_string_list(member)?);
  162    152   
                }
  163    153   
                _ => {}
  164    154   
            }
  165    155   
            Ok(())
  166    156   
        })?;
  167    157   
        Ok(builder.build())
  168    158   
    }
  169    159   
}
         160  +
impl ResourceTypeOption {
         161  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         162  +
    pub fn deserialize_with_response(
         163  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         164  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         165  +
        _status: u16,
         166  +
        _body: &[u8],
         167  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         168  +
        Self::deserialize(deserializer)
         169  +
    }
         170  +
}
  170    171   
impl ResourceTypeOption {
  171    172   
    /// Creates a new builder-style object to manufacture [`ResourceTypeOption`](crate::types::ResourceTypeOption).
  172    173   
    pub fn builder() -> crate::types::builders::ResourceTypeOptionBuilder {
  173    174   
        crate::types::builders::ResourceTypeOptionBuilder::default()
  174    175   
    }
  175    176   
}
  176    177   
  177    178   
/// A builder for [`ResourceTypeOption`](crate::types::ResourceTypeOption).
  178    179   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    180   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_resource_type_request.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_response_error.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_response_launch_template_data.rs

@@ -279,279 +691,691 @@
  299    299   
    "com.amazonaws.ec2",
  300    300   
    "ResponseLaunchTemplateData",
  301    301   
);
  302    302   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_KERNEL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  303    303   
    ::aws_smithy_schema::ShapeId::from_static(
  304    304   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$KernelId",
  305    305   
        "com.amazonaws.ec2",
  306    306   
        "ResponseLaunchTemplateData",
  307    307   
    ),
  308    308   
    ::aws_smithy_schema::ShapeType::String,
  309         -
    "kernel_id",
         309  +
    "KernelId",
  310    310   
    0,
  311    311   
)
  312    312   
.with_xml_name("kernelId");
  313    313   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_EBS_OPTIMIZED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  314    314   
    ::aws_smithy_schema::ShapeId::from_static(
  315    315   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$EbsOptimized",
  316    316   
        "com.amazonaws.ec2",
  317    317   
        "ResponseLaunchTemplateData",
  318    318   
    ),
  319    319   
    ::aws_smithy_schema::ShapeType::Boolean,
  320         -
    "ebs_optimized",
         320  +
    "EbsOptimized",
  321    321   
    1,
  322    322   
)
  323    323   
.with_xml_name("ebsOptimized");
  324    324   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_IAM_INSTANCE_PROFILE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  325    325   
    ::aws_smithy_schema::ShapeId::from_static(
  326    326   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$IamInstanceProfile",
  327    327   
        "com.amazonaws.ec2",
  328    328   
        "ResponseLaunchTemplateData",
  329    329   
    ),
  330    330   
    ::aws_smithy_schema::ShapeType::Structure,
  331         -
    "iam_instance_profile",
         331  +
    "IamInstanceProfile",
  332    332   
    2,
  333    333   
)
  334    334   
.with_xml_name("iamInstanceProfile");
  335    335   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_BLOCK_DEVICE_MAPPINGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  336    336   
    ::aws_smithy_schema::ShapeId::from_static(
  337    337   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$BlockDeviceMappings",
  338    338   
        "com.amazonaws.ec2",
  339    339   
        "ResponseLaunchTemplateData",
  340    340   
    ),
  341    341   
    ::aws_smithy_schema::ShapeType::List,
  342         -
    "block_device_mappings",
         342  +
    "BlockDeviceMappings",
  343    343   
    3,
  344    344   
)
  345    345   
.with_xml_name("blockDeviceMappingSet");
  346    346   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_NETWORK_INTERFACES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  347    347   
    ::aws_smithy_schema::ShapeId::from_static(
  348    348   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$NetworkInterfaces",
  349    349   
        "com.amazonaws.ec2",
  350    350   
        "ResponseLaunchTemplateData",
  351    351   
    ),
  352    352   
    ::aws_smithy_schema::ShapeType::List,
  353         -
    "network_interfaces",
         353  +
    "NetworkInterfaces",
  354    354   
    4,
  355    355   
)
  356    356   
.with_xml_name("networkInterfaceSet");
  357    357   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_IMAGE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  358    358   
    ::aws_smithy_schema::ShapeId::from_static(
  359    359   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$ImageId",
  360    360   
        "com.amazonaws.ec2",
  361    361   
        "ResponseLaunchTemplateData",
  362    362   
    ),
  363    363   
    ::aws_smithy_schema::ShapeType::String,
  364         -
    "image_id",
         364  +
    "ImageId",
  365    365   
    5,
  366    366   
)
  367    367   
.with_xml_name("imageId");
  368    368   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  369    369   
    ::aws_smithy_schema::ShapeId::from_static(
  370    370   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$InstanceType",
  371    371   
        "com.amazonaws.ec2",
  372    372   
        "ResponseLaunchTemplateData",
  373    373   
    ),
  374    374   
    ::aws_smithy_schema::ShapeType::String,
  375         -
    "instance_type",
         375  +
    "InstanceType",
  376    376   
    6,
  377    377   
)
  378    378   
.with_xml_name("instanceType");
  379    379   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_KEY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  380    380   
    ::aws_smithy_schema::ShapeId::from_static(
  381    381   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$KeyName",
  382    382   
        "com.amazonaws.ec2",
  383    383   
        "ResponseLaunchTemplateData",
  384    384   
    ),
  385    385   
    ::aws_smithy_schema::ShapeType::String,
  386         -
    "key_name",
         386  +
    "KeyName",
  387    387   
    7,
  388    388   
)
  389    389   
.with_xml_name("keyName");
  390    390   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_MONITORING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  391    391   
    ::aws_smithy_schema::ShapeId::from_static(
  392    392   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$Monitoring",
  393    393   
        "com.amazonaws.ec2",
  394    394   
        "ResponseLaunchTemplateData",
  395    395   
    ),
  396    396   
    ::aws_smithy_schema::ShapeType::Structure,
  397         -
    "monitoring",
         397  +
    "Monitoring",
  398    398   
    8,
  399    399   
)
  400    400   
.with_xml_name("monitoring");
  401    401   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_PLACEMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  402    402   
    ::aws_smithy_schema::ShapeId::from_static(
  403    403   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$Placement",
  404    404   
        "com.amazonaws.ec2",
  405    405   
        "ResponseLaunchTemplateData",
  406    406   
    ),
  407    407   
    ::aws_smithy_schema::ShapeType::Structure,
  408         -
    "placement",
         408  +
    "Placement",
  409    409   
    9,
  410    410   
)
  411    411   
.with_xml_name("placement");
  412    412   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_RAM_DISK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  413    413   
    ::aws_smithy_schema::ShapeId::from_static(
  414    414   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$RamDiskId",
  415    415   
        "com.amazonaws.ec2",
  416    416   
        "ResponseLaunchTemplateData",
  417    417   
    ),
  418    418   
    ::aws_smithy_schema::ShapeType::String,
  419         -
    "ram_disk_id",
         419  +
    "RamDiskId",
  420    420   
    10,
  421    421   
)
  422    422   
.with_xml_name("ramDiskId");
  423    423   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_DISABLE_API_TERMINATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  424    424   
    ::aws_smithy_schema::ShapeId::from_static(
  425    425   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$DisableApiTermination",
  426    426   
        "com.amazonaws.ec2",
  427    427   
        "ResponseLaunchTemplateData",
  428    428   
    ),
  429    429   
    ::aws_smithy_schema::ShapeType::Boolean,
  430         -
    "disable_api_termination",
         430  +
    "DisableApiTermination",
  431    431   
    11,
  432    432   
)
  433    433   
.with_xml_name("disableApiTermination");
  434    434   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_INSTANCE_INITIATED_SHUTDOWN_BEHAVIOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  435    435   
    ::aws_smithy_schema::ShapeId::from_static(
  436    436   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$InstanceInitiatedShutdownBehavior",
  437    437   
        "com.amazonaws.ec2",
  438    438   
        "ResponseLaunchTemplateData",
  439    439   
    ),
  440    440   
    ::aws_smithy_schema::ShapeType::String,
  441         -
    "instance_initiated_shutdown_behavior",
         441  +
    "InstanceInitiatedShutdownBehavior",
  442    442   
    12,
  443    443   
)
  444    444   
.with_xml_name("instanceInitiatedShutdownBehavior");
  445    445   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_USER_DATA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  446    446   
    ::aws_smithy_schema::ShapeId::from_static(
  447    447   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$UserData",
  448    448   
        "com.amazonaws.ec2",
  449    449   
        "ResponseLaunchTemplateData",
  450    450   
    ),
  451    451   
    ::aws_smithy_schema::ShapeType::String,
  452         -
    "user_data",
         452  +
    "UserData",
  453    453   
    13,
  454    454   
)
  455    455   
.with_xml_name("userData");
  456    456   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_TAG_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  457    457   
    ::aws_smithy_schema::ShapeId::from_static(
  458    458   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$TagSpecifications",
  459    459   
        "com.amazonaws.ec2",
  460    460   
        "ResponseLaunchTemplateData",
  461    461   
    ),
  462    462   
    ::aws_smithy_schema::ShapeType::List,
  463         -
    "tag_specifications",
         463  +
    "TagSpecifications",
  464    464   
    14,
  465    465   
)
  466    466   
.with_xml_name("tagSpecificationSet");
  467    467   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_ELASTIC_GPU_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  468    468   
    ::aws_smithy_schema::ShapeId::from_static(
  469    469   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$ElasticGpuSpecifications",
  470    470   
        "com.amazonaws.ec2",
  471    471   
        "ResponseLaunchTemplateData",
  472    472   
    ),
  473    473   
    ::aws_smithy_schema::ShapeType::List,
  474         -
    "elastic_gpu_specifications",
         474  +
    "ElasticGpuSpecifications",
  475    475   
    15,
  476    476   
)
  477    477   
.with_xml_name("elasticGpuSpecificationSet");
  478    478   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_ELASTIC_INFERENCE_ACCELERATORS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  479    479   
    ::aws_smithy_schema::ShapeId::from_static(
  480    480   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$ElasticInferenceAccelerators",
  481    481   
        "com.amazonaws.ec2",
  482    482   
        "ResponseLaunchTemplateData",
  483    483   
    ),
  484    484   
    ::aws_smithy_schema::ShapeType::List,
  485         -
    "elastic_inference_accelerators",
         485  +
    "ElasticInferenceAccelerators",
  486    486   
    16,
  487    487   
)
  488    488   
.with_xml_name("elasticInferenceAcceleratorSet");
  489    489   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_SECURITY_GROUP_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  490    490   
    ::aws_smithy_schema::ShapeId::from_static(
  491    491   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$SecurityGroupIds",
  492    492   
        "com.amazonaws.ec2",
  493    493   
        "ResponseLaunchTemplateData",
  494    494   
    ),
  495    495   
    ::aws_smithy_schema::ShapeType::List,
  496         -
    "security_group_ids",
         496  +
    "SecurityGroupIds",
  497    497   
    17,
  498    498   
)
  499    499   
.with_xml_name("securityGroupIdSet");
  500    500   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_SECURITY_GROUPS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  501    501   
    ::aws_smithy_schema::ShapeId::from_static(
  502    502   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$SecurityGroups",
  503    503   
        "com.amazonaws.ec2",
  504    504   
        "ResponseLaunchTemplateData",
  505    505   
    ),
  506    506   
    ::aws_smithy_schema::ShapeType::List,
  507         -
    "security_groups",
         507  +
    "SecurityGroups",
  508    508   
    18,
  509    509   
)
  510    510   
.with_xml_name("securityGroupSet");
  511    511   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_INSTANCE_MARKET_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  512    512   
    ::aws_smithy_schema::ShapeId::from_static(
  513    513   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$InstanceMarketOptions",
  514    514   
        "com.amazonaws.ec2",
  515    515   
        "ResponseLaunchTemplateData",
  516    516   
    ),
  517    517   
    ::aws_smithy_schema::ShapeType::Structure,
  518         -
    "instance_market_options",
         518  +
    "InstanceMarketOptions",
  519    519   
    19,
  520    520   
)
  521    521   
.with_xml_name("instanceMarketOptions");
  522    522   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_CREDIT_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  523    523   
    ::aws_smithy_schema::ShapeId::from_static(
  524    524   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$CreditSpecification",
  525    525   
        "com.amazonaws.ec2",
  526    526   
        "ResponseLaunchTemplateData",
  527    527   
    ),
  528    528   
    ::aws_smithy_schema::ShapeType::Structure,
  529         -
    "credit_specification",
         529  +
    "CreditSpecification",
  530    530   
    20,
  531    531   
)
  532    532   
.with_xml_name("creditSpecification");
  533    533   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_CPU_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  534    534   
    ::aws_smithy_schema::ShapeId::from_static(
  535    535   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$CpuOptions",
  536    536   
        "com.amazonaws.ec2",
  537    537   
        "ResponseLaunchTemplateData",
  538    538   
    ),
  539    539   
    ::aws_smithy_schema::ShapeType::Structure,
  540         -
    "cpu_options",
         540  +
    "CpuOptions",
  541    541   
    21,
  542    542   
)
  543    543   
.with_xml_name("cpuOptions");
  544    544   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_CAPACITY_RESERVATION_SPECIFICATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  545    545   
    ::aws_smithy_schema::ShapeId::from_static(
  546    546   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$CapacityReservationSpecification",
  547    547   
        "com.amazonaws.ec2",
  548    548   
        "ResponseLaunchTemplateData",
  549    549   
    ),
  550    550   
    ::aws_smithy_schema::ShapeType::Structure,
  551         -
    "capacity_reservation_specification",
         551  +
    "CapacityReservationSpecification",
  552    552   
    22,
  553    553   
)
  554    554   
.with_xml_name("capacityReservationSpecification");
  555    555   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_LICENSE_SPECIFICATIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  556    556   
    ::aws_smithy_schema::ShapeId::from_static(
  557    557   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$LicenseSpecifications",
  558    558   
        "com.amazonaws.ec2",
  559    559   
        "ResponseLaunchTemplateData",
  560    560   
    ),
  561    561   
    ::aws_smithy_schema::ShapeType::List,
  562         -
    "license_specifications",
         562  +
    "LicenseSpecifications",
  563    563   
    23,
  564    564   
)
  565    565   
.with_xml_name("licenseSet");
  566    566   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_HIBERNATION_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  567    567   
    ::aws_smithy_schema::ShapeId::from_static(
  568    568   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$HibernationOptions",
  569    569   
        "com.amazonaws.ec2",
  570    570   
        "ResponseLaunchTemplateData",
  571    571   
    ),
  572    572   
    ::aws_smithy_schema::ShapeType::Structure,
  573         -
    "hibernation_options",
         573  +
    "HibernationOptions",
  574    574   
    24,
  575    575   
)
  576    576   
.with_xml_name("hibernationOptions");
  577    577   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_METADATA_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  578    578   
    ::aws_smithy_schema::ShapeId::from_static(
  579    579   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$MetadataOptions",
  580    580   
        "com.amazonaws.ec2",
  581    581   
        "ResponseLaunchTemplateData",
  582    582   
    ),
  583    583   
    ::aws_smithy_schema::ShapeType::Structure,
  584         -
    "metadata_options",
         584  +
    "MetadataOptions",
  585    585   
    25,
  586    586   
)
  587    587   
.with_xml_name("metadataOptions");
  588    588   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_ENCLAVE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  589    589   
    ::aws_smithy_schema::ShapeId::from_static(
  590    590   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$EnclaveOptions",
  591    591   
        "com.amazonaws.ec2",
  592    592   
        "ResponseLaunchTemplateData",
  593    593   
    ),
  594    594   
    ::aws_smithy_schema::ShapeType::Structure,
  595         -
    "enclave_options",
         595  +
    "EnclaveOptions",
  596    596   
    26,
  597    597   
)
  598    598   
.with_xml_name("enclaveOptions");
  599    599   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_INSTANCE_REQUIREMENTS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  600    600   
    ::aws_smithy_schema::ShapeId::from_static(
  601    601   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$InstanceRequirements",
  602    602   
        "com.amazonaws.ec2",
  603    603   
        "ResponseLaunchTemplateData",
  604    604   
    ),
  605    605   
    ::aws_smithy_schema::ShapeType::Structure,
  606         -
    "instance_requirements",
         606  +
    "InstanceRequirements",
  607    607   
    27,
  608    608   
)
  609    609   
.with_xml_name("instanceRequirements");
  610    610   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_PRIVATE_DNS_NAME_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  611    611   
    ::aws_smithy_schema::ShapeId::from_static(
  612    612   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$PrivateDnsNameOptions",
  613    613   
        "com.amazonaws.ec2",
  614    614   
        "ResponseLaunchTemplateData",
  615    615   
    ),
  616    616   
    ::aws_smithy_schema::ShapeType::Structure,
  617         -
    "private_dns_name_options",
         617  +
    "PrivateDnsNameOptions",
  618    618   
    28,
  619    619   
)
  620    620   
.with_xml_name("privateDnsNameOptions");
  621    621   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_MAINTENANCE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  622    622   
    ::aws_smithy_schema::ShapeId::from_static(
  623    623   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$MaintenanceOptions",
  624    624   
        "com.amazonaws.ec2",
  625    625   
        "ResponseLaunchTemplateData",
  626    626   
    ),
  627    627   
    ::aws_smithy_schema::ShapeType::Structure,
  628         -
    "maintenance_options",
         628  +
    "MaintenanceOptions",
  629    629   
    29,
  630    630   
)
  631    631   
.with_xml_name("maintenanceOptions");
  632    632   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_DISABLE_API_STOP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  633    633   
    ::aws_smithy_schema::ShapeId::from_static(
  634    634   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$DisableApiStop",
  635    635   
        "com.amazonaws.ec2",
  636    636   
        "ResponseLaunchTemplateData",
  637    637   
    ),
  638    638   
    ::aws_smithy_schema::ShapeType::Boolean,
  639         -
    "disable_api_stop",
         639  +
    "DisableApiStop",
  640    640   
    30,
  641    641   
)
  642    642   
.with_xml_name("disableApiStop");
  643    643   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  644    644   
    ::aws_smithy_schema::ShapeId::from_static(
  645    645   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$Operator",
  646    646   
        "com.amazonaws.ec2",
  647    647   
        "ResponseLaunchTemplateData",
  648    648   
    ),
  649    649   
    ::aws_smithy_schema::ShapeType::Structure,
  650         -
    "operator",
         650  +
    "Operator",
  651    651   
    31,
  652    652   
)
  653    653   
.with_xml_name("operator");
  654    654   
static RESPONSELAUNCHTEMPLATEDATA_MEMBER_NETWORK_PERFORMANCE_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  655    655   
    ::aws_smithy_schema::ShapeId::from_static(
  656    656   
        "com.amazonaws.ec2#ResponseLaunchTemplateData$NetworkPerformanceOptions",
  657    657   
        "com.amazonaws.ec2",
  658    658   
        "ResponseLaunchTemplateData",
  659    659   
    ),
  660    660   
    ::aws_smithy_schema::ShapeType::Structure,
  661         -
    "network_performance_options",
         661  +
    "NetworkPerformanceOptions",
  662    662   
    32,
  663    663   
)
  664    664   
.with_xml_name("networkPerformanceOptions");
  665    665   
static RESPONSELAUNCHTEMPLATEDATA_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  666    666   
    RESPONSELAUNCHTEMPLATEDATA_SCHEMA_ID,
  667    667   
    ::aws_smithy_schema::ShapeType::Structure,
  668    668   
    &[
  669    669   
        &RESPONSELAUNCHTEMPLATEDATA_MEMBER_KERNEL_ID,
  670    670   
        &RESPONSELAUNCHTEMPLATEDATA_MEMBER_EBS_OPTIMIZED,
  671    671   
        &RESPONSELAUNCHTEMPLATEDATA_MEMBER_IAM_INSTANCE_PROFILE,
@@ -852,852 +1112,1085 @@
  872    872   
            ser.write_struct(&RESPONSELAUNCHTEMPLATEDATA_MEMBER_OPERATOR, val)?;
  873    873   
        }
  874    874   
        if let Some(ref val) = self.network_performance_options {
  875    875   
            ser.write_struct(&RESPONSELAUNCHTEMPLATEDATA_MEMBER_NETWORK_PERFORMANCE_OPTIONS, val)?;
  876    876   
        }
  877    877   
        Ok(())
  878    878   
    }
  879    879   
}
  880    880   
impl ResponseLaunchTemplateData {
  881    881   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  882         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  883         -
        deserializer: &mut D,
         882  +
    pub fn deserialize(
         883  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  884    884   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  885    885   
        #[allow(unused_variables, unused_mut)]
  886    886   
        let mut builder = Self::builder();
  887    887   
        #[allow(
  888    888   
            unused_variables,
  889    889   
            unreachable_code,
  890    890   
            clippy::single_match,
  891    891   
            clippy::match_single_binding,
  892    892   
            clippy::diverging_sub_expression
  893    893   
        )]
  894         -
        deserializer.read_struct(&RESPONSELAUNCHTEMPLATEDATA_SCHEMA, (), |_, member, deser| {
         894  +
        deserializer.read_struct(&RESPONSELAUNCHTEMPLATEDATA_SCHEMA, &mut |member, deser| {
  895    895   
            match member.member_index() {
  896    896   
                Some(0) => {
  897    897   
                    builder.kernel_id = Some(deser.read_string(member)?);
  898    898   
                }
  899    899   
                Some(1) => {
  900    900   
                    builder.ebs_optimized = Some(deser.read_boolean(member)?);
  901    901   
                }
  902    902   
                Some(2) => {
  903    903   
                    builder.iam_instance_profile = Some(crate::types::LaunchTemplateIamInstanceProfileSpecification::deserialize(deser)?);
  904    904   
                }
  905    905   
                Some(3) => {
  906    906   
                    builder.block_device_mappings = Some({
  907         -
                        let container = if let Some(cap) = deser.container_size() {
  908         -
                            Vec::with_capacity(cap)
  909         -
                        } else {
  910         -
                            Vec::new()
  911         -
                        };
  912         -
                        deser.read_list(member, container, |mut list, deser| {
  913         -
                            list.push(crate::types::LaunchTemplateBlockDeviceMapping::deserialize(deser)?);
  914         -
                            Ok(list)
  915         -
                        })?
         907  +
                        let mut container = Vec::new();
         908  +
                        deser.read_list(member, &mut |deser| {
         909  +
                            container.push(crate::types::LaunchTemplateBlockDeviceMapping::deserialize(deser)?);
         910  +
                            Ok(())
         911  +
                        })?;
         912  +
                        container
  916    913   
                    });
  917    914   
                }
  918    915   
                Some(4) => {
  919    916   
                    builder.network_interfaces = Some({
  920         -
                        let container = if let Some(cap) = deser.container_size() {
  921         -
                            Vec::with_capacity(cap)
  922         -
                        } else {
  923         -
                            Vec::new()
  924         -
                        };
  925         -
                        deser.read_list(member, container, |mut list, deser| {
  926         -
                            list.push(crate::types::LaunchTemplateInstanceNetworkInterfaceSpecification::deserialize(deser)?);
  927         -
                            Ok(list)
  928         -
                        })?
         917  +
                        let mut container = Vec::new();
         918  +
                        deser.read_list(member, &mut |deser| {
         919  +
                            container.push(crate::types::LaunchTemplateInstanceNetworkInterfaceSpecification::deserialize(deser)?);
         920  +
                            Ok(())
         921  +
                        })?;
         922  +
                        container
  929    923   
                    });
  930    924   
                }
  931    925   
                Some(5) => {
  932    926   
                    builder.image_id = Some(deser.read_string(member)?);
  933    927   
                }
  934    928   
                Some(6) => {
  935    929   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  936    930   
                }
  937    931   
                Some(7) => {
  938    932   
                    builder.key_name = Some(deser.read_string(member)?);
  939    933   
                }
  940    934   
                Some(8) => {
  941    935   
                    builder.monitoring = Some(crate::types::LaunchTemplatesMonitoring::deserialize(deser)?);
  942    936   
                }
  943    937   
                Some(9) => {
  944    938   
                    builder.placement = Some(crate::types::LaunchTemplatePlacement::deserialize(deser)?);
  945    939   
                }
  946    940   
                Some(10) => {
  947    941   
                    builder.ram_disk_id = Some(deser.read_string(member)?);
  948    942   
                }
  949    943   
                Some(11) => {
  950    944   
                    builder.disable_api_termination = Some(deser.read_boolean(member)?);
  951    945   
                }
  952    946   
                Some(12) => {
  953    947   
                    builder.instance_initiated_shutdown_behavior = Some(crate::types::ShutdownBehavior::from(deser.read_string(member)?.as_str()));
  954    948   
                }
  955    949   
                Some(13) => {
  956    950   
                    builder.user_data = Some(deser.read_string(member)?);
  957    951   
                }
  958    952   
                Some(14) => {
  959    953   
                    builder.tag_specifications = Some({
  960         -
                        let container = if let Some(cap) = deser.container_size() {
  961         -
                            Vec::with_capacity(cap)
  962         -
                        } else {
  963         -
                            Vec::new()
  964         -
                        };
  965         -
                        deser.read_list(member, container, |mut list, deser| {
  966         -
                            list.push(crate::types::LaunchTemplateTagSpecification::deserialize(deser)?);
  967         -
                            Ok(list)
  968         -
                        })?
         954  +
                        let mut container = Vec::new();
         955  +
                        deser.read_list(member, &mut |deser| {
         956  +
                            container.push(crate::types::LaunchTemplateTagSpecification::deserialize(deser)?);
         957  +
                            Ok(())
         958  +
                        })?;
         959  +
                        container
  969    960   
                    });
  970    961   
                }
  971    962   
                Some(15) => {
  972    963   
                    builder.elastic_gpu_specifications = Some({
  973         -
                        let container = if let Some(cap) = deser.container_size() {
  974         -
                            Vec::with_capacity(cap)
  975         -
                        } else {
  976         -
                            Vec::new()
  977         -
                        };
  978         -
                        deser.read_list(member, container, |mut list, deser| {
  979         -
                            list.push(crate::types::ElasticGpuSpecificationResponse::deserialize(deser)?);
  980         -
                            Ok(list)
  981         -
                        })?
         964  +
                        let mut container = Vec::new();
         965  +
                        deser.read_list(member, &mut |deser| {
         966  +
                            container.push(crate::types::ElasticGpuSpecificationResponse::deserialize(deser)?);
         967  +
                            Ok(())
         968  +
                        })?;
         969  +
                        container
  982    970   
                    });
  983    971   
                }
  984    972   
                Some(16) => {
  985    973   
                    builder.elastic_inference_accelerators = Some({
  986         -
                        let container = if let Some(cap) = deser.container_size() {
  987         -
                            Vec::with_capacity(cap)
  988         -
                        } else {
  989         -
                            Vec::new()
  990         -
                        };
  991         -
                        deser.read_list(member, container, |mut list, deser| {
  992         -
                            list.push(crate::types::LaunchTemplateElasticInferenceAcceleratorResponse::deserialize(deser)?);
  993         -
                            Ok(list)
  994         -
                        })?
         974  +
                        let mut container = Vec::new();
         975  +
                        deser.read_list(member, &mut |deser| {
         976  +
                            container.push(crate::types::LaunchTemplateElasticInferenceAcceleratorResponse::deserialize(deser)?);
         977  +
                            Ok(())
         978  +
                        })?;
         979  +
                        container
  995    980   
                    });
  996    981   
                }
  997    982   
                Some(17) => {
  998         -
                    builder.security_group_ids = Some({
  999         -
                        let container = if let Some(cap) = deser.container_size() {
 1000         -
                            Vec::with_capacity(cap)
 1001         -
                        } else {
 1002         -
                            Vec::new()
 1003         -
                        };
 1004         -
                        deser.read_list(member, container, |mut list, deser| {
 1005         -
                            list.push(deser.read_string(member)?);
 1006         -
                            Ok(list)
 1007         -
                        })?
 1008         -
                    });
         983  +
                    builder.security_group_ids = Some(deser.read_string_list(member)?);
 1009    984   
                }
 1010    985   
                Some(18) => {
 1011         -
                    builder.security_groups = Some({
 1012         -
                        let container = if let Some(cap) = deser.container_size() {
 1013         -
                            Vec::with_capacity(cap)
 1014         -
                        } else {
 1015         -
                            Vec::new()
 1016         -
                        };
 1017         -
                        deser.read_list(member, container, |mut list, deser| {
 1018         -
                            list.push(deser.read_string(member)?);
 1019         -
                            Ok(list)
 1020         -
                        })?
 1021         -
                    });
         986  +
                    builder.security_groups = Some(deser.read_string_list(member)?);
 1022    987   
                }
 1023    988   
                Some(19) => {
 1024    989   
                    builder.instance_market_options = Some(crate::types::LaunchTemplateInstanceMarketOptions::deserialize(deser)?);
 1025    990   
                }
 1026    991   
                Some(20) => {
 1027    992   
                    builder.credit_specification = Some(crate::types::CreditSpecification::deserialize(deser)?);
 1028    993   
                }
 1029    994   
                Some(21) => {
 1030    995   
                    builder.cpu_options = Some(crate::types::LaunchTemplateCpuOptions::deserialize(deser)?);
 1031    996   
                }
 1032    997   
                Some(22) => {
 1033    998   
                    builder.capacity_reservation_specification =
 1034    999   
                        Some(crate::types::LaunchTemplateCapacityReservationSpecificationResponse::deserialize(deser)?);
 1035   1000   
                }
 1036   1001   
                Some(23) => {
 1037   1002   
                    builder.license_specifications = Some({
 1038         -
                        let container = if let Some(cap) = deser.container_size() {
 1039         -
                            Vec::with_capacity(cap)
 1040         -
                        } else {
 1041         -
                            Vec::new()
 1042         -
                        };
 1043         -
                        deser.read_list(member, container, |mut list, deser| {
 1044         -
                            list.push(crate::types::LaunchTemplateLicenseConfiguration::deserialize(deser)?);
 1045         -
                            Ok(list)
 1046         -
                        })?
        1003  +
                        let mut container = Vec::new();
        1004  +
                        deser.read_list(member, &mut |deser| {
        1005  +
                            container.push(crate::types::LaunchTemplateLicenseConfiguration::deserialize(deser)?);
        1006  +
                            Ok(())
        1007  +
                        })?;
        1008  +
                        container
 1047   1009   
                    });
 1048   1010   
                }
 1049   1011   
                Some(24) => {
 1050   1012   
                    builder.hibernation_options = Some(crate::types::LaunchTemplateHibernationOptions::deserialize(deser)?);
 1051   1013   
                }
 1052   1014   
                Some(25) => {
 1053   1015   
                    builder.metadata_options = Some(crate::types::LaunchTemplateInstanceMetadataOptions::deserialize(deser)?);
 1054   1016   
                }
 1055   1017   
                Some(26) => {
 1056   1018   
                    builder.enclave_options = Some(crate::types::LaunchTemplateEnclaveOptions::deserialize(deser)?);
 1057   1019   
                }
 1058   1020   
                Some(27) => {
 1059   1021   
                    builder.instance_requirements = Some(crate::types::InstanceRequirements::deserialize(deser)?);
 1060   1022   
                }
 1061   1023   
                Some(28) => {
 1062   1024   
                    builder.private_dns_name_options = Some(crate::types::LaunchTemplatePrivateDnsNameOptions::deserialize(deser)?);
 1063   1025   
                }
 1064   1026   
                Some(29) => {
 1065   1027   
                    builder.maintenance_options = Some(crate::types::LaunchTemplateInstanceMaintenanceOptions::deserialize(deser)?);
 1066   1028   
                }
 1067   1029   
                Some(30) => {
 1068   1030   
                    builder.disable_api_stop = Some(deser.read_boolean(member)?);
 1069   1031   
                }
 1070   1032   
                Some(31) => {
 1071   1033   
                    builder.operator = Some(crate::types::OperatorResponse::deserialize(deser)?);
 1072   1034   
                }
 1073   1035   
                Some(32) => {
 1074   1036   
                    builder.network_performance_options = Some(crate::types::LaunchTemplateNetworkPerformanceOptions::deserialize(deser)?);
 1075   1037   
                }
 1076   1038   
                _ => {}
 1077   1039   
            }
 1078   1040   
            Ok(())
 1079   1041   
        })?;
 1080   1042   
        Ok(builder.build())
 1081   1043   
    }
 1082   1044   
}
        1045  +
impl ResponseLaunchTemplateData {
        1046  +
    /// Deserializes this structure from a body deserializer and HTTP response.
        1047  +
    pub fn deserialize_with_response(
        1048  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
        1049  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
        1050  +
        _status: u16,
        1051  +
        _body: &[u8],
        1052  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
        1053  +
        Self::deserialize(deserializer)
        1054  +
    }
        1055  +
}
 1083   1056   
impl ResponseLaunchTemplateData {
 1084   1057   
    /// Creates a new builder-style object to manufacture [`ResponseLaunchTemplateData`](crate::types::ResponseLaunchTemplateData).
 1085   1058   
    pub fn builder() -> crate::types::builders::ResponseLaunchTemplateDataBuilder {
 1086   1059   
        crate::types::builders::ResponseLaunchTemplateDataBuilder::default()
 1087   1060   
    }
 1088   1061   
}
 1089   1062   
 1090   1063   
/// A builder for [`ResponseLaunchTemplateData`](crate::types::ResponseLaunchTemplateData).
 1091   1064   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
 1092   1065   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_revoked_security_group_rule.rs

@@ -58,58 +228,228 @@
   78     78   
    "com.amazonaws.ec2",
   79     79   
    "RevokedSecurityGroupRule",
   80     80   
);
   81     81   
static REVOKEDSECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$SecurityGroupRuleId",
   84     84   
        "com.amazonaws.ec2",
   85     85   
        "RevokedSecurityGroupRule",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "security_group_rule_id",
          88  +
    "SecurityGroupRuleId",
   89     89   
    0,
   90     90   
)
   91     91   
.with_xml_name("securityGroupRuleId");
   92     92   
static REVOKEDSECURITYGROUPRULE_MEMBER_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$GroupId",
   95     95   
        "com.amazonaws.ec2",
   96     96   
        "RevokedSecurityGroupRule",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::String,
   99         -
    "group_id",
          99  +
    "GroupId",
  100    100   
    1,
  101    101   
)
  102    102   
.with_xml_name("groupId");
  103    103   
static REVOKEDSECURITYGROUPRULE_MEMBER_IS_EGRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static(
  105    105   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$IsEgress",
  106    106   
        "com.amazonaws.ec2",
  107    107   
        "RevokedSecurityGroupRule",
  108    108   
    ),
  109    109   
    ::aws_smithy_schema::ShapeType::Boolean,
  110         -
    "is_egress",
         110  +
    "IsEgress",
  111    111   
    2,
  112    112   
)
  113    113   
.with_xml_name("isEgress");
  114    114   
static REVOKEDSECURITYGROUPRULE_MEMBER_IP_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  115    115   
    ::aws_smithy_schema::ShapeId::from_static(
  116    116   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$IpProtocol",
  117    117   
        "com.amazonaws.ec2",
  118    118   
        "RevokedSecurityGroupRule",
  119    119   
    ),
  120    120   
    ::aws_smithy_schema::ShapeType::String,
  121         -
    "ip_protocol",
         121  +
    "IpProtocol",
  122    122   
    3,
  123    123   
)
  124    124   
.with_xml_name("ipProtocol");
  125    125   
static REVOKEDSECURITYGROUPRULE_MEMBER_FROM_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$FromPort",
  128    128   
        "com.amazonaws.ec2",
  129    129   
        "RevokedSecurityGroupRule",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Integer,
  132         -
    "from_port",
         132  +
    "FromPort",
  133    133   
    4,
  134    134   
)
  135    135   
.with_xml_name("fromPort");
  136    136   
static REVOKEDSECURITYGROUPRULE_MEMBER_TO_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$ToPort",
  139    139   
        "com.amazonaws.ec2",
  140    140   
        "RevokedSecurityGroupRule",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::Integer,
  143         -
    "to_port",
         143  +
    "ToPort",
  144    144   
    5,
  145    145   
)
  146    146   
.with_xml_name("toPort");
  147    147   
static REVOKEDSECURITYGROUPRULE_MEMBER_CIDR_IPV4: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static(
  149    149   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$CidrIpv4",
  150    150   
        "com.amazonaws.ec2",
  151    151   
        "RevokedSecurityGroupRule",
  152    152   
    ),
  153    153   
    ::aws_smithy_schema::ShapeType::String,
  154         -
    "cidr_ipv4",
         154  +
    "CidrIpv4",
  155    155   
    6,
  156    156   
)
  157    157   
.with_xml_name("cidrIpv4");
  158    158   
static REVOKEDSECURITYGROUPRULE_MEMBER_CIDR_IPV6: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  159    159   
    ::aws_smithy_schema::ShapeId::from_static(
  160    160   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$CidrIpv6",
  161    161   
        "com.amazonaws.ec2",
  162    162   
        "RevokedSecurityGroupRule",
  163    163   
    ),
  164    164   
    ::aws_smithy_schema::ShapeType::String,
  165         -
    "cidr_ipv6",
         165  +
    "CidrIpv6",
  166    166   
    7,
  167    167   
)
  168    168   
.with_xml_name("cidrIpv6");
  169    169   
static REVOKEDSECURITYGROUPRULE_MEMBER_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  170    170   
    ::aws_smithy_schema::ShapeId::from_static(
  171    171   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$PrefixListId",
  172    172   
        "com.amazonaws.ec2",
  173    173   
        "RevokedSecurityGroupRule",
  174    174   
    ),
  175    175   
    ::aws_smithy_schema::ShapeType::String,
  176         -
    "prefix_list_id",
         176  +
    "PrefixListId",
  177    177   
    8,
  178    178   
)
  179    179   
.with_xml_name("prefixListId");
  180    180   
static REVOKEDSECURITYGROUPRULE_MEMBER_REFERENCED_GROUP_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  181    181   
    ::aws_smithy_schema::ShapeId::from_static(
  182    182   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$ReferencedGroupId",
  183    183   
        "com.amazonaws.ec2",
  184    184   
        "RevokedSecurityGroupRule",
  185    185   
    ),
  186    186   
    ::aws_smithy_schema::ShapeType::String,
  187         -
    "referenced_group_id",
         187  +
    "ReferencedGroupId",
  188    188   
    9,
  189    189   
)
  190    190   
.with_xml_name("referencedGroupId");
  191    191   
static REVOKEDSECURITYGROUPRULE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  192    192   
    ::aws_smithy_schema::ShapeId::from_static(
  193    193   
        "com.amazonaws.ec2#RevokedSecurityGroupRule$Description",
  194    194   
        "com.amazonaws.ec2",
  195    195   
        "RevokedSecurityGroupRule",
  196    196   
    ),
  197    197   
    ::aws_smithy_schema::ShapeType::String,
  198         -
    "description",
         198  +
    "Description",
  199    199   
    10,
  200    200   
)
  201    201   
.with_xml_name("description");
  202    202   
static REVOKEDSECURITYGROUPRULE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  203    203   
    REVOKEDSECURITYGROUPRULE_SCHEMA_ID,
  204    204   
    ::aws_smithy_schema::ShapeType::Structure,
  205    205   
    &[
  206    206   
        &REVOKEDSECURITYGROUPRULE_MEMBER_SECURITY_GROUP_RULE_ID,
  207    207   
        &REVOKEDSECURITYGROUPRULE_MEMBER_GROUP_ID,
  208    208   
        &REVOKEDSECURITYGROUPRULE_MEMBER_IS_EGRESS,
@@ -237,237 +350,361 @@
  257    257   
            ser.write_string(&REVOKEDSECURITYGROUPRULE_MEMBER_REFERENCED_GROUP_ID, val)?;
  258    258   
        }
  259    259   
        if let Some(ref val) = self.description {
  260    260   
            ser.write_string(&REVOKEDSECURITYGROUPRULE_MEMBER_DESCRIPTION, val)?;
  261    261   
        }
  262    262   
        Ok(())
  263    263   
    }
  264    264   
}
  265    265   
impl RevokedSecurityGroupRule {
  266    266   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  267         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  268         -
        deserializer: &mut D,
         267  +
    pub fn deserialize(
         268  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  269    269   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  270    270   
        #[allow(unused_variables, unused_mut)]
  271    271   
        let mut builder = Self::builder();
  272    272   
        #[allow(
  273    273   
            unused_variables,
  274    274   
            unreachable_code,
  275    275   
            clippy::single_match,
  276    276   
            clippy::match_single_binding,
  277    277   
            clippy::diverging_sub_expression
  278    278   
        )]
  279         -
        deserializer.read_struct(&REVOKEDSECURITYGROUPRULE_SCHEMA, (), |_, member, deser| {
         279  +
        deserializer.read_struct(&REVOKEDSECURITYGROUPRULE_SCHEMA, &mut |member, deser| {
  280    280   
            match member.member_index() {
  281    281   
                Some(0) => {
  282    282   
                    builder.security_group_rule_id = Some(deser.read_string(member)?);
  283    283   
                }
  284    284   
                Some(1) => {
  285    285   
                    builder.group_id = Some(deser.read_string(member)?);
  286    286   
                }
  287    287   
                Some(2) => {
  288    288   
                    builder.is_egress = Some(deser.read_boolean(member)?);
  289    289   
                }
  290    290   
                Some(3) => {
  291    291   
                    builder.ip_protocol = Some(deser.read_string(member)?);
  292    292   
                }
  293    293   
                Some(4) => {
  294    294   
                    builder.from_port = Some(deser.read_integer(member)?);
  295    295   
                }
  296    296   
                Some(5) => {
  297    297   
                    builder.to_port = Some(deser.read_integer(member)?);
  298    298   
                }
  299    299   
                Some(6) => {
  300    300   
                    builder.cidr_ipv4 = Some(deser.read_string(member)?);
  301    301   
                }
  302    302   
                Some(7) => {
  303    303   
                    builder.cidr_ipv6 = Some(deser.read_string(member)?);
  304    304   
                }
  305    305   
                Some(8) => {
  306    306   
                    builder.prefix_list_id = Some(deser.read_string(member)?);
  307    307   
                }
  308    308   
                Some(9) => {
  309    309   
                    builder.referenced_group_id = Some(deser.read_string(member)?);
  310    310   
                }
  311    311   
                Some(10) => {
  312    312   
                    builder.description = Some(deser.read_string(member)?);
  313    313   
                }
  314    314   
                _ => {}
  315    315   
            }
  316    316   
            Ok(())
  317    317   
        })?;
  318    318   
        Ok(builder.build())
  319    319   
    }
  320    320   
}
         321  +
impl RevokedSecurityGroupRule {
         322  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         323  +
    pub fn deserialize_with_response(
         324  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         325  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         326  +
        _status: u16,
         327  +
        _body: &[u8],
         328  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         329  +
        Self::deserialize(deserializer)
         330  +
    }
         331  +
}
  321    332   
impl RevokedSecurityGroupRule {
  322    333   
    /// Creates a new builder-style object to manufacture [`RevokedSecurityGroupRule`](crate::types::RevokedSecurityGroupRule).
  323    334   
    pub fn builder() -> crate::types::builders::RevokedSecurityGroupRuleBuilder {
  324    335   
        crate::types::builders::RevokedSecurityGroupRuleBuilder::default()
  325    336   
    }
  326    337   
}
  327    338   
  328    339   
/// A builder for [`RevokedSecurityGroupRule`](crate::types::RevokedSecurityGroupRule).
  329    340   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  330    341   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route.rs

@@ -113,113 +292,292 @@
  133    133   
    /// <p>The next hop IP address for routes propagated by VPC Route Server into VPC route tables.</p>
  134    134   
    pub fn ip_address(&self) -> ::std::option::Option<&str> {
  135    135   
        self.ip_address.as_deref()
  136    136   
    }
  137    137   
}
  138    138   
static ROUTE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  139    139   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route", "com.amazonaws.ec2", "Route");
  140    140   
static ROUTE_MEMBER_DESTINATION_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$DestinationCidrBlock", "com.amazonaws.ec2", "Route"),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "destination_cidr_block",
         143  +
    "DestinationCidrBlock",
  144    144   
    0,
  145    145   
)
  146    146   
.with_xml_name("destinationCidrBlock");
  147    147   
static ROUTE_MEMBER_DESTINATION_IPV6_CIDR_BLOCK: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  148    148   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$DestinationIpv6CidrBlock", "com.amazonaws.ec2", "Route"),
  149    149   
    ::aws_smithy_schema::ShapeType::String,
  150         -
    "destination_ipv6_cidr_block",
         150  +
    "DestinationIpv6CidrBlock",
  151    151   
    1,
  152    152   
)
  153    153   
.with_xml_name("destinationIpv6CidrBlock");
  154    154   
static ROUTE_MEMBER_DESTINATION_PREFIX_LIST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  155    155   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$DestinationPrefixListId", "com.amazonaws.ec2", "Route"),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "destination_prefix_list_id",
         157  +
    "DestinationPrefixListId",
  158    158   
    2,
  159    159   
)
  160    160   
.with_xml_name("destinationPrefixListId");
  161    161   
static ROUTE_MEMBER_EGRESS_ONLY_INTERNET_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  162    162   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$EgressOnlyInternetGatewayId", "com.amazonaws.ec2", "Route"),
  163    163   
    ::aws_smithy_schema::ShapeType::String,
  164         -
    "egress_only_internet_gateway_id",
         164  +
    "EgressOnlyInternetGatewayId",
  165    165   
    3,
  166    166   
)
  167    167   
.with_xml_name("egressOnlyInternetGatewayId");
  168    168   
static ROUTE_MEMBER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  169    169   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$GatewayId", "com.amazonaws.ec2", "Route"),
  170    170   
    ::aws_smithy_schema::ShapeType::String,
  171         -
    "gateway_id",
         171  +
    "GatewayId",
  172    172   
    4,
  173    173   
)
  174    174   
.with_xml_name("gatewayId");
  175    175   
static ROUTE_MEMBER_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$InstanceId", "com.amazonaws.ec2", "Route"),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "instance_id",
         178  +
    "InstanceId",
  179    179   
    5,
  180    180   
)
  181    181   
.with_xml_name("instanceId");
  182    182   
static ROUTE_MEMBER_INSTANCE_OWNER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$InstanceOwnerId", "com.amazonaws.ec2", "Route"),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "instance_owner_id",
         185  +
    "InstanceOwnerId",
  186    186   
    6,
  187    187   
)
  188    188   
.with_xml_name("instanceOwnerId");
  189    189   
static ROUTE_MEMBER_NAT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$NatGatewayId", "com.amazonaws.ec2", "Route"),
  191    191   
    ::aws_smithy_schema::ShapeType::String,
  192         -
    "nat_gateway_id",
         192  +
    "NatGatewayId",
  193    193   
    7,
  194    194   
)
  195    195   
.with_xml_name("natGatewayId");
  196    196   
static ROUTE_MEMBER_TRANSIT_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$TransitGatewayId", "com.amazonaws.ec2", "Route"),
  198    198   
    ::aws_smithy_schema::ShapeType::String,
  199         -
    "transit_gateway_id",
         199  +
    "TransitGatewayId",
  200    200   
    8,
  201    201   
)
  202    202   
.with_xml_name("transitGatewayId");
  203    203   
static ROUTE_MEMBER_LOCAL_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  204    204   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$LocalGatewayId", "com.amazonaws.ec2", "Route"),
  205    205   
    ::aws_smithy_schema::ShapeType::String,
  206         -
    "local_gateway_id",
         206  +
    "LocalGatewayId",
  207    207   
    9,
  208    208   
)
  209    209   
.with_xml_name("localGatewayId");
  210    210   
static ROUTE_MEMBER_CARRIER_GATEWAY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  211    211   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$CarrierGatewayId", "com.amazonaws.ec2", "Route"),
  212    212   
    ::aws_smithy_schema::ShapeType::String,
  213         -
    "carrier_gateway_id",
         213  +
    "CarrierGatewayId",
  214    214   
    10,
  215    215   
)
  216    216   
.with_xml_name("carrierGatewayId");
  217    217   
static ROUTE_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  218    218   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$NetworkInterfaceId", "com.amazonaws.ec2", "Route"),
  219    219   
    ::aws_smithy_schema::ShapeType::String,
  220         -
    "network_interface_id",
         220  +
    "NetworkInterfaceId",
  221    221   
    11,
  222    222   
)
  223    223   
.with_xml_name("networkInterfaceId");
  224    224   
static ROUTE_MEMBER_ORIGIN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  225    225   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$Origin", "com.amazonaws.ec2", "Route"),
  226    226   
    ::aws_smithy_schema::ShapeType::String,
  227         -
    "origin",
         227  +
    "Origin",
  228    228   
    12,
  229    229   
)
  230    230   
.with_xml_name("origin");
  231    231   
static ROUTE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  232    232   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$State", "com.amazonaws.ec2", "Route"),
  233    233   
    ::aws_smithy_schema::ShapeType::String,
  234         -
    "state",
         234  +
    "State",
  235    235   
    13,
  236    236   
)
  237    237   
.with_xml_name("state");
  238    238   
static ROUTE_MEMBER_VPC_PEERING_CONNECTION_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  239    239   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$VpcPeeringConnectionId", "com.amazonaws.ec2", "Route"),
  240    240   
    ::aws_smithy_schema::ShapeType::String,
  241         -
    "vpc_peering_connection_id",
         241  +
    "VpcPeeringConnectionId",
  242    242   
    14,
  243    243   
)
  244    244   
.with_xml_name("vpcPeeringConnectionId");
  245    245   
static ROUTE_MEMBER_CORE_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  246    246   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$CoreNetworkArn", "com.amazonaws.ec2", "Route"),
  247    247   
    ::aws_smithy_schema::ShapeType::String,
  248         -
    "core_network_arn",
         248  +
    "CoreNetworkArn",
  249    249   
    15,
  250    250   
)
  251    251   
.with_xml_name("coreNetworkArn");
  252    252   
static ROUTE_MEMBER_ODB_NETWORK_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  253    253   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$OdbNetworkArn", "com.amazonaws.ec2", "Route"),
  254    254   
    ::aws_smithy_schema::ShapeType::String,
  255         -
    "odb_network_arn",
         255  +
    "OdbNetworkArn",
  256    256   
    16,
  257    257   
)
  258    258   
.with_xml_name("odbNetworkArn");
  259    259   
static ROUTE_MEMBER_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  260    260   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#Route$IpAddress", "com.amazonaws.ec2", "Route"),
  261    261   
    ::aws_smithy_schema::ShapeType::String,
  262         -
    "ip_address",
         262  +
    "IpAddress",
  263    263   
    17,
  264    264   
)
  265    265   
.with_xml_name("ipAddress");
  266    266   
static ROUTE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  267    267   
    ROUTE_SCHEMA_ID,
  268    268   
    ::aws_smithy_schema::ShapeType::Structure,
  269    269   
    &[
  270    270   
        &ROUTE_MEMBER_DESTINATION_CIDR_BLOCK,
  271    271   
        &ROUTE_MEMBER_DESTINATION_IPV6_CIDR_BLOCK,
  272    272   
        &ROUTE_MEMBER_DESTINATION_PREFIX_LIST_ID,
@@ -329,329 +401,401 @@
  349    349   
            ser.write_string(&ROUTE_MEMBER_ODB_NETWORK_ARN, val)?;
  350    350   
        }
  351    351   
        if let Some(ref val) = self.ip_address {
  352    352   
            ser.write_string(&ROUTE_MEMBER_IP_ADDRESS, val)?;
  353    353   
        }
  354    354   
        Ok(())
  355    355   
    }
  356    356   
}
  357    357   
impl Route {
  358    358   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  359         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  360         -
        deserializer: &mut D,
         359  +
    pub fn deserialize(
         360  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  361    361   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  362    362   
        #[allow(unused_variables, unused_mut)]
  363    363   
        let mut builder = Self::builder();
  364    364   
        #[allow(
  365    365   
            unused_variables,
  366    366   
            unreachable_code,
  367    367   
            clippy::single_match,
  368    368   
            clippy::match_single_binding,
  369    369   
            clippy::diverging_sub_expression
  370    370   
        )]
  371         -
        deserializer.read_struct(&ROUTE_SCHEMA, (), |_, member, deser| {
         371  +
        deserializer.read_struct(&ROUTE_SCHEMA, &mut |member, deser| {
  372    372   
            match member.member_index() {
  373    373   
                Some(0) => {
  374    374   
                    builder.destination_cidr_block = Some(deser.read_string(member)?);
  375    375   
                }
  376    376   
                Some(1) => {
  377    377   
                    builder.destination_ipv6_cidr_block = Some(deser.read_string(member)?);
  378    378   
                }
  379    379   
                Some(2) => {
  380    380   
                    builder.destination_prefix_list_id = Some(deser.read_string(member)?);
  381    381   
                }
@@ -404,404 +463,474 @@
  424    424   
                Some(17) => {
  425    425   
                    builder.ip_address = Some(deser.read_string(member)?);
  426    426   
                }
  427    427   
                _ => {}
  428    428   
            }
  429    429   
            Ok(())
  430    430   
        })?;
  431    431   
        Ok(builder.build())
  432    432   
    }
  433    433   
}
         434  +
impl Route {
         435  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         436  +
    pub fn deserialize_with_response(
         437  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         438  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         439  +
        _status: u16,
         440  +
        _body: &[u8],
         441  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         442  +
        Self::deserialize(deserializer)
         443  +
    }
         444  +
}
  434    445   
impl Route {
  435    446   
    /// Creates a new builder-style object to manufacture [`Route`](crate::types::Route).
  436    447   
    pub fn builder() -> crate::types::builders::RouteBuilder {
  437    448   
        crate::types::builders::RouteBuilder::default()
  438    449   
    }
  439    450   
}
  440    451   
  441    452   
/// A builder for [`Route`](crate::types::Route).
  442    453   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  443    454   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server.rs

@@ -48,48 +161,161 @@
   68     68   
    /// <p>The ARN of the SNS topic where notifications are published.</p>
   69     69   
    pub fn sns_topic_arn(&self) -> ::std::option::Option<&str> {
   70     70   
        self.sns_topic_arn.as_deref()
   71     71   
    }
   72     72   
}
   73     73   
static ROUTESERVER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   74     74   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer", "com.amazonaws.ec2", "RouteServer");
   75     75   
static ROUTESERVER_MEMBER_ROUTE_SERVER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$RouteServerId", "com.amazonaws.ec2", "RouteServer"),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "route_server_id",
          78  +
    "RouteServerId",
   79     79   
    0,
   80     80   
)
   81     81   
.with_xml_name("routeServerId");
   82     82   
static ROUTESERVER_MEMBER_AMAZON_SIDE_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$AmazonSideAsn", "com.amazonaws.ec2", "RouteServer"),
   84     84   
    ::aws_smithy_schema::ShapeType::Long,
   85         -
    "amazon_side_asn",
          85  +
    "AmazonSideAsn",
   86     86   
    1,
   87     87   
)
   88     88   
.with_xml_name("amazonSideAsn");
   89     89   
static ROUTESERVER_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$State", "com.amazonaws.ec2", "RouteServer"),
   91     91   
    ::aws_smithy_schema::ShapeType::String,
   92         -
    "state",
          92  +
    "State",
   93     93   
    2,
   94     94   
)
   95     95   
.with_xml_name("state");
   96     96   
static ROUTESERVER_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$Tags", "com.amazonaws.ec2", "RouteServer"),
   98     98   
    ::aws_smithy_schema::ShapeType::List,
   99         -
    "tags",
          99  +
    "Tags",
  100    100   
    3,
  101    101   
)
  102    102   
.with_xml_name("tagSet");
  103    103   
static ROUTESERVER_MEMBER_PERSIST_ROUTES_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  104    104   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$PersistRoutesState", "com.amazonaws.ec2", "RouteServer"),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "persist_routes_state",
         106  +
    "PersistRoutesState",
  107    107   
    4,
  108    108   
)
  109    109   
.with_xml_name("persistRoutesState");
  110    110   
static ROUTESERVER_MEMBER_PERSIST_ROUTES_DURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  111    111   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$PersistRoutesDuration", "com.amazonaws.ec2", "RouteServer"),
  112    112   
    ::aws_smithy_schema::ShapeType::Long,
  113         -
    "persist_routes_duration",
         113  +
    "PersistRoutesDuration",
  114    114   
    5,
  115    115   
)
  116    116   
.with_xml_name("persistRoutesDuration");
  117    117   
static ROUTESERVER_MEMBER_SNS_NOTIFICATIONS_ENABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.ec2#RouteServer$SnsNotificationsEnabled",
  120    120   
        "com.amazonaws.ec2",
  121    121   
        "RouteServer",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::Boolean,
  124         -
    "sns_notifications_enabled",
         124  +
    "SnsNotificationsEnabled",
  125    125   
    6,
  126    126   
)
  127    127   
.with_xml_name("snsNotificationsEnabled");
  128    128   
static ROUTESERVER_MEMBER_SNS_TOPIC_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServer$SnsTopicArn", "com.amazonaws.ec2", "RouteServer"),
  130    130   
    ::aws_smithy_schema::ShapeType::String,
  131         -
    "sns_topic_arn",
         131  +
    "SnsTopicArn",
  132    132   
    7,
  133    133   
)
  134    134   
.with_xml_name("snsTopicArn");
  135    135   
static ROUTESERVER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  136    136   
    ROUTESERVER_SCHEMA_ID,
  137    137   
    ::aws_smithy_schema::ShapeType::Structure,
  138    138   
    &[
  139    139   
        &ROUTESERVER_MEMBER_ROUTE_SERVER_ID,
  140    140   
        &ROUTESERVER_MEMBER_AMAZON_SIDE_ASN,
  141    141   
        &ROUTESERVER_MEMBER_STATE,
@@ -163,163 +277,285 @@
  183    183   
            ser.write_boolean(&ROUTESERVER_MEMBER_SNS_NOTIFICATIONS_ENABLED, *val)?;
  184    184   
        }
  185    185   
        if let Some(ref val) = self.sns_topic_arn {
  186    186   
            ser.write_string(&ROUTESERVER_MEMBER_SNS_TOPIC_ARN, val)?;
  187    187   
        }
  188    188   
        Ok(())
  189    189   
    }
  190    190   
}
  191    191   
impl RouteServer {
  192    192   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  193         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  194         -
        deserializer: &mut D,
         193  +
    pub fn deserialize(
         194  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  195    195   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  196    196   
        #[allow(unused_variables, unused_mut)]
  197    197   
        let mut builder = Self::builder();
  198    198   
        #[allow(
  199    199   
            unused_variables,
  200    200   
            unreachable_code,
  201    201   
            clippy::single_match,
  202    202   
            clippy::match_single_binding,
  203    203   
            clippy::diverging_sub_expression
  204    204   
        )]
  205         -
        deserializer.read_struct(&ROUTESERVER_SCHEMA, (), |_, member, deser| {
         205  +
        deserializer.read_struct(&ROUTESERVER_SCHEMA, &mut |member, deser| {
  206    206   
            match member.member_index() {
  207    207   
                Some(0) => {
  208    208   
                    builder.route_server_id = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(1) => {
  211    211   
                    builder.amazon_side_asn = Some(deser.read_long(member)?);
  212    212   
                }
  213    213   
                Some(2) => {
  214    214   
                    builder.state = Some(crate::types::RouteServerState::from(deser.read_string(member)?.as_str()));
  215    215   
                }
  216    216   
                Some(3) => {
  217    217   
                    builder.tags = Some({
  218         -
                        let container = if let Some(cap) = deser.container_size() {
  219         -
                            Vec::with_capacity(cap)
  220         -
                        } else {
  221         -
                            Vec::new()
  222         -
                        };
  223         -
                        deser.read_list(member, container, |mut list, deser| {
  224         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  225         -
                            Ok(list)
  226         -
                        })?
         218  +
                        let mut container = Vec::new();
         219  +
                        deser.read_list(member, &mut |deser| {
         220  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         221  +
                            Ok(())
         222  +
                        })?;
         223  +
                        container
  227    224   
                    });
  228    225   
                }
  229    226   
                Some(4) => {
  230    227   
                    builder.persist_routes_state = Some(crate::types::RouteServerPersistRoutesState::from(deser.read_string(member)?.as_str()));
  231    228   
                }
  232    229   
                Some(5) => {
  233    230   
                    builder.persist_routes_duration = Some(deser.read_long(member)?);
  234    231   
                }
  235    232   
                Some(6) => {
  236    233   
                    builder.sns_notifications_enabled = Some(deser.read_boolean(member)?);
  237    234   
                }
  238    235   
                Some(7) => {
  239    236   
                    builder.sns_topic_arn = Some(deser.read_string(member)?);
  240    237   
                }
  241    238   
                _ => {}
  242    239   
            }
  243    240   
            Ok(())
  244    241   
        })?;
  245    242   
        Ok(builder.build())
  246    243   
    }
  247    244   
}
         245  +
impl RouteServer {
         246  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         247  +
    pub fn deserialize_with_response(
         248  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         249  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         250  +
        _status: u16,
         251  +
        _body: &[u8],
         252  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         253  +
        Self::deserialize(deserializer)
         254  +
    }
         255  +
}
  248    256   
impl RouteServer {
  249    257   
    /// Creates a new builder-style object to manufacture [`RouteServer`](crate::types::RouteServer).
  250    258   
    pub fn builder() -> crate::types::builders::RouteServerBuilder {
  251    259   
        crate::types::builders::RouteServerBuilder::default()
  252    260   
    }
  253    261   
}
  254    262   
  255    263   
/// A builder for [`RouteServer`](crate::types::RouteServer).
  256    264   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  257    265   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_association.rs

@@ -8,8 +156,167 @@
   28     28   
}
   29     29   
static ROUTESERVERASSOCIATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   30     30   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerAssociation", "com.amazonaws.ec2", "RouteServerAssociation");
   31     31   
static ROUTESERVERASSOCIATION_MEMBER_ROUTE_SERVER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.ec2#RouteServerAssociation$RouteServerId",
   34     34   
        "com.amazonaws.ec2",
   35     35   
        "RouteServerAssociation",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::String,
   38         -
    "route_server_id",
          38  +
    "RouteServerId",
   39     39   
    0,
   40     40   
)
   41     41   
.with_xml_name("routeServerId");
   42     42   
static ROUTESERVERASSOCIATION_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2#RouteServerAssociation$VpcId",
   45     45   
        "com.amazonaws.ec2",
   46     46   
        "RouteServerAssociation",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "vpc_id",
          49  +
    "VpcId",
   50     50   
    1,
   51     51   
)
   52     52   
.with_xml_name("vpcId");
   53     53   
static ROUTESERVERASSOCIATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#RouteServerAssociation$State",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "RouteServerAssociation",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "state",
          60  +
    "State",
   61     61   
    2,
   62     62   
)
   63     63   
.with_xml_name("state");
   64     64   
static ROUTESERVERASSOCIATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    ROUTESERVERASSOCIATION_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &ROUTESERVERASSOCIATION_MEMBER_ROUTE_SERVER_ID,
   69     69   
        &ROUTESERVERASSOCIATION_MEMBER_VPC_ID,
   70     70   
        &ROUTESERVERASSOCIATION_MEMBER_STATE,
   71     71   
    ],
   72     72   
);
   73     73   
impl RouteServerAssociation {
   74     74   
    /// The schema for this shape.
   75     75   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERASSOCIATION_SCHEMA;
   76     76   
}
   77     77   
impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerAssociation {
   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.route_server_id {
   84     84   
            ser.write_string(&ROUTESERVERASSOCIATION_MEMBER_ROUTE_SERVER_ID, val)?;
   85     85   
        }
   86     86   
        if let Some(ref val) = self.vpc_id {
   87     87   
            ser.write_string(&ROUTESERVERASSOCIATION_MEMBER_VPC_ID, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.state {
   90     90   
            ser.write_string(&ROUTESERVERASSOCIATION_MEMBER_STATE, val.as_str())?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl RouteServerAssociation {
   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(&ROUTESERVERASSOCIATION_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&ROUTESERVERASSOCIATION_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.route_server_id = Some(deser.read_string(member)?);
  113    113   
                }
  114    114   
                Some(1) => {
  115    115   
                    builder.vpc_id = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(2) => {
  118    118   
                    builder.state = Some(crate::types::RouteServerAssociationState::from(deser.read_string(member)?.as_str()));
  119    119   
                }
  120    120   
                _ => {}
  121    121   
            }
  122    122   
            Ok(())
  123    123   
        })?;
  124    124   
        Ok(builder.build())
  125    125   
    }
  126    126   
}
         127  +
impl RouteServerAssociation {
         128  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         129  +
    pub fn deserialize_with_response(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         131  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         132  +
        _status: u16,
         133  +
        _body: &[u8],
         134  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         135  +
        Self::deserialize(deserializer)
         136  +
    }
         137  +
}
  127    138   
impl RouteServerAssociation {
  128    139   
    /// Creates a new builder-style object to manufacture [`RouteServerAssociation`](crate::types::RouteServerAssociation).
  129    140   
    pub fn builder() -> crate::types::builders::RouteServerAssociationBuilder {
  130    141   
        crate::types::builders::RouteServerAssociationBuilder::default()
  131    142   
    }
  132    143   
}
  133    144   
  134    145   
/// A builder for [`RouteServerAssociation`](crate::types::RouteServerAssociation).
  135    146   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    147   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_bfd_status.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_bgp_options.rs

@@ -17,17 +147,158 @@
   37     37   
}
   38     38   
static ROUTESERVERBGPOPTIONS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   39     39   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerBgpOptions", "com.amazonaws.ec2", "RouteServerBgpOptions");
   40     40   
static ROUTESERVERBGPOPTIONS_MEMBER_PEER_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   41     41   
    ::aws_smithy_schema::ShapeId::from_static(
   42     42   
        "com.amazonaws.ec2#RouteServerBgpOptions$PeerAsn",
   43     43   
        "com.amazonaws.ec2",
   44     44   
        "RouteServerBgpOptions",
   45     45   
    ),
   46     46   
    ::aws_smithy_schema::ShapeType::Long,
   47         -
    "peer_asn",
          47  +
    "PeerAsn",
   48     48   
    0,
   49     49   
)
   50     50   
.with_xml_name("peerAsn");
   51     51   
static ROUTESERVERBGPOPTIONS_MEMBER_PEER_LIVENESS_DETECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2#RouteServerBgpOptions$PeerLivenessDetection",
   54     54   
        "com.amazonaws.ec2",
   55     55   
        "RouteServerBgpOptions",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "peer_liveness_detection",
          58  +
    "PeerLivenessDetection",
   59     59   
    1,
   60     60   
)
   61     61   
.with_xml_name("peerLivenessDetection");
   62     62   
static ROUTESERVERBGPOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   63     63   
    ROUTESERVERBGPOPTIONS_SCHEMA_ID,
   64     64   
    ::aws_smithy_schema::ShapeType::Structure,
   65     65   
    &[
   66     66   
        &ROUTESERVERBGPOPTIONS_MEMBER_PEER_ASN,
   67     67   
        &ROUTESERVERBGPOPTIONS_MEMBER_PEER_LIVENESS_DETECTION,
   68     68   
    ],
   69     69   
);
   70     70   
impl RouteServerBgpOptions {
   71     71   
    /// The schema for this shape.
   72     72   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERBGPOPTIONS_SCHEMA;
   73     73   
}
   74     74   
impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerBgpOptions {
   75     75   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   76     76   
    fn serialize_members(
   77     77   
        &self,
   78     78   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   79     79   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   80     80   
        if let Some(ref val) = self.peer_asn {
   81     81   
            ser.write_long(&ROUTESERVERBGPOPTIONS_MEMBER_PEER_ASN, *val)?;
   82     82   
        }
   83     83   
        if let Some(ref val) = self.peer_liveness_detection {
   84     84   
            ser.write_string(&ROUTESERVERBGPOPTIONS_MEMBER_PEER_LIVENESS_DETECTION, val.as_str())?;
   85     85   
        }
   86     86   
        Ok(())
   87     87   
    }
   88     88   
}
   89     89   
impl RouteServerBgpOptions {
   90     90   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   91         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   92         -
        deserializer: &mut D,
          91  +
    pub fn deserialize(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   93     93   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   94     94   
        #[allow(unused_variables, unused_mut)]
   95     95   
        let mut builder = Self::builder();
   96     96   
        #[allow(
   97     97   
            unused_variables,
   98     98   
            unreachable_code,
   99     99   
            clippy::single_match,
  100    100   
            clippy::match_single_binding,
  101    101   
            clippy::diverging_sub_expression
  102    102   
        )]
  103         -
        deserializer.read_struct(&ROUTESERVERBGPOPTIONS_SCHEMA, (), |_, member, deser| {
         103  +
        deserializer.read_struct(&ROUTESERVERBGPOPTIONS_SCHEMA, &mut |member, deser| {
  104    104   
            match member.member_index() {
  105    105   
                Some(0) => {
  106    106   
                    builder.peer_asn = Some(deser.read_long(member)?);
  107    107   
                }
  108    108   
                Some(1) => {
  109    109   
                    builder.peer_liveness_detection = Some(crate::types::RouteServerPeerLivenessMode::from(deser.read_string(member)?.as_str()));
  110    110   
                }
  111    111   
                _ => {}
  112    112   
            }
  113    113   
            Ok(())
  114    114   
        })?;
  115    115   
        Ok(builder.build())
  116    116   
    }
  117    117   
}
         118  +
impl RouteServerBgpOptions {
         119  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         120  +
    pub fn deserialize_with_response(
         121  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         122  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         123  +
        _status: u16,
         124  +
        _body: &[u8],
         125  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         126  +
        Self::deserialize(deserializer)
         127  +
    }
         128  +
}
  118    129   
impl RouteServerBgpOptions {
  119    130   
    /// Creates a new builder-style object to manufacture [`RouteServerBgpOptions`](crate::types::RouteServerBgpOptions).
  120    131   
    pub fn builder() -> crate::types::builders::RouteServerBgpOptionsBuilder {
  121    132   
        crate::types::builders::RouteServerBgpOptionsBuilder::default()
  122    133   
    }
  123    134   
}
  124    135   
  125    136   
/// A builder for [`RouteServerBgpOptions`](crate::types::RouteServerBgpOptions).
  126    137   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  127    138   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_bgp_options_request.rs

@@ -18,18 +146,157 @@
   38     38   
    "com.amazonaws.ec2",
   39     39   
    "RouteServerBgpOptionsRequest",
   40     40   
);
   41     41   
static ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_ASN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.ec2#RouteServerBgpOptionsRequest$PeerAsn",
   44     44   
        "com.amazonaws.ec2",
   45     45   
        "RouteServerBgpOptionsRequest",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::Long,
   48         -
    "peer_asn",
          48  +
    "PeerAsn",
   49     49   
    0,
   50     50   
);
   51     51   
static ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_LIVENESS_DETECTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2#RouteServerBgpOptionsRequest$PeerLivenessDetection",
   54     54   
        "com.amazonaws.ec2",
   55     55   
        "RouteServerBgpOptionsRequest",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "peer_liveness_detection",
          58  +
    "PeerLivenessDetection",
   59     59   
    1,
   60     60   
);
   61     61   
static ROUTESERVERBGPOPTIONSREQUEST_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   62     62   
    ROUTESERVERBGPOPTIONSREQUEST_SCHEMA_ID,
   63     63   
    ::aws_smithy_schema::ShapeType::Structure,
   64     64   
    &[
   65     65   
        &ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_ASN,
   66     66   
        &ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_LIVENESS_DETECTION,
   67     67   
    ],
   68     68   
);
   69     69   
impl RouteServerBgpOptionsRequest {
   70     70   
    /// The schema for this shape.
   71     71   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERBGPOPTIONSREQUEST_SCHEMA;
   72     72   
}
   73     73   
impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerBgpOptionsRequest {
   74     74   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   75     75   
    fn serialize_members(
   76     76   
        &self,
   77     77   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   78     78   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        if let Some(ref val) = self.peer_asn {
   80     80   
            ser.write_long(&ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_ASN, *val)?;
   81     81   
        }
   82     82   
        if let Some(ref val) = self.peer_liveness_detection {
   83     83   
            ser.write_string(&ROUTESERVERBGPOPTIONSREQUEST_MEMBER_PEER_LIVENESS_DETECTION, val.as_str())?;
   84     84   
        }
   85     85   
        Ok(())
   86     86   
    }
   87     87   
}
   88     88   
impl RouteServerBgpOptionsRequest {
   89     89   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   90         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   91         -
        deserializer: &mut D,
          90  +
    pub fn deserialize(
          91  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   92     92   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   93     93   
        #[allow(unused_variables, unused_mut)]
   94     94   
        let mut builder = Self::builder();
   95     95   
        #[allow(
   96     96   
            unused_variables,
   97     97   
            unreachable_code,
   98     98   
            clippy::single_match,
   99     99   
            clippy::match_single_binding,
  100    100   
            clippy::diverging_sub_expression
  101    101   
        )]
  102         -
        deserializer.read_struct(&ROUTESERVERBGPOPTIONSREQUEST_SCHEMA, (), |_, member, deser| {
         102  +
        deserializer.read_struct(&ROUTESERVERBGPOPTIONSREQUEST_SCHEMA, &mut |member, deser| {
  103    103   
            match member.member_index() {
  104    104   
                Some(0) => {
  105    105   
                    builder.peer_asn = Some(deser.read_long(member)?);
  106    106   
                }
  107    107   
                Some(1) => {
  108    108   
                    builder.peer_liveness_detection = Some(crate::types::RouteServerPeerLivenessMode::from(deser.read_string(member)?.as_str()));
  109    109   
                }
  110    110   
                _ => {}
  111    111   
            }
  112    112   
            Ok(())
  113    113   
        })?;
  114    114   
        Ok(builder.build())
  115    115   
    }
  116    116   
}
         117  +
impl RouteServerBgpOptionsRequest {
         118  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         119  +
    pub fn deserialize_with_response(
         120  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         121  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         122  +
        _status: u16,
         123  +
        _body: &[u8],
         124  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         125  +
        Self::deserialize(deserializer)
         126  +
    }
         127  +
}
  117    128   
impl RouteServerBgpOptionsRequest {
  118    129   
    /// Creates a new builder-style object to manufacture [`RouteServerBgpOptionsRequest`](crate::types::RouteServerBgpOptionsRequest).
  119    130   
    pub fn builder() -> crate::types::builders::RouteServerBgpOptionsRequestBuilder {
  120    131   
        crate::types::builders::RouteServerBgpOptionsRequestBuilder::default()
  121    132   
    }
  122    133   
}
  123    134   
  124    135   
/// A builder for [`RouteServerBgpOptionsRequest`](crate::types::RouteServerBgpOptionsRequest).
  125    136   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  126    137   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_bgp_status.rs

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

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_endpoint.rs

@@ -46,46 +178,178 @@
   66     66   
}
   67     67   
static ROUTESERVERENDPOINT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   68     68   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerEndpoint", "com.amazonaws.ec2", "RouteServerEndpoint");
   69     69   
static ROUTESERVERENDPOINT_MEMBER_ROUTE_SERVER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ec2#RouteServerEndpoint$RouteServerId",
   72     72   
        "com.amazonaws.ec2",
   73     73   
        "RouteServerEndpoint",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::String,
   76         -
    "route_server_id",
          76  +
    "RouteServerId",
   77     77   
    0,
   78     78   
)
   79     79   
.with_xml_name("routeServerId");
   80     80   
static ROUTESERVERENDPOINT_MEMBER_ROUTE_SERVER_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.ec2#RouteServerEndpoint$RouteServerEndpointId",
   83     83   
        "com.amazonaws.ec2",
   84     84   
        "RouteServerEndpoint",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::String,
   87         -
    "route_server_endpoint_id",
          87  +
    "RouteServerEndpointId",
   88     88   
    1,
   89     89   
)
   90     90   
.with_xml_name("routeServerEndpointId");
   91     91   
static ROUTESERVERENDPOINT_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerEndpoint$VpcId", "com.amazonaws.ec2", "RouteServerEndpoint"),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "vpc_id",
          94  +
    "VpcId",
   95     95   
    2,
   96     96   
)
   97     97   
.with_xml_name("vpcId");
   98     98   
static ROUTESERVERENDPOINT_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.ec2#RouteServerEndpoint$SubnetId",
  101    101   
        "com.amazonaws.ec2",
  102    102   
        "RouteServerEndpoint",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "subnet_id",
         105  +
    "SubnetId",
  106    106   
    3,
  107    107   
)
  108    108   
.with_xml_name("subnetId");
  109    109   
static ROUTESERVERENDPOINT_MEMBER_ENI_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerEndpoint$EniId", "com.amazonaws.ec2", "RouteServerEndpoint"),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "eni_id",
         112  +
    "EniId",
  113    113   
    4,
  114    114   
)
  115    115   
.with_xml_name("eniId");
  116    116   
static ROUTESERVERENDPOINT_MEMBER_ENI_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.ec2#RouteServerEndpoint$EniAddress",
  119    119   
        "com.amazonaws.ec2",
  120    120   
        "RouteServerEndpoint",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::String,
  123         -
    "eni_address",
         123  +
    "EniAddress",
  124    124   
    5,
  125    125   
)
  126    126   
.with_xml_name("eniAddress");
  127    127   
static ROUTESERVERENDPOINT_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerEndpoint$State", "com.amazonaws.ec2", "RouteServerEndpoint"),
  129    129   
    ::aws_smithy_schema::ShapeType::String,
  130         -
    "state",
         130  +
    "State",
  131    131   
    6,
  132    132   
)
  133    133   
.with_xml_name("state");
  134    134   
static ROUTESERVERENDPOINT_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  135    135   
    ::aws_smithy_schema::ShapeId::from_static(
  136    136   
        "com.amazonaws.ec2#RouteServerEndpoint$FailureReason",
  137    137   
        "com.amazonaws.ec2",
  138    138   
        "RouteServerEndpoint",
  139    139   
    ),
  140    140   
    ::aws_smithy_schema::ShapeType::String,
  141         -
    "failure_reason",
         141  +
    "FailureReason",
  142    142   
    7,
  143    143   
)
  144    144   
.with_xml_name("failureReason");
  145    145   
static ROUTESERVERENDPOINT_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerEndpoint$Tags", "com.amazonaws.ec2", "RouteServerEndpoint"),
  147    147   
    ::aws_smithy_schema::ShapeType::List,
  148         -
    "tags",
         148  +
    "Tags",
  149    149   
    8,
  150    150   
)
  151    151   
.with_xml_name("tagSet");
  152    152   
static ROUTESERVERENDPOINT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  153    153   
    ROUTESERVERENDPOINT_SCHEMA_ID,
  154    154   
    ::aws_smithy_schema::ShapeType::Structure,
  155    155   
    &[
  156    156   
        &ROUTESERVERENDPOINT_MEMBER_ROUTE_SERVER_ID,
  157    157   
        &ROUTESERVERENDPOINT_MEMBER_ROUTE_SERVER_ENDPOINT_ID,
  158    158   
        &ROUTESERVERENDPOINT_MEMBER_VPC_ID,
@@ -187,187 +304,312 @@
  207    207   
                    }
  208    208   
                    Ok(())
  209    209   
                },
  210    210   
            )?;
  211    211   
        }
  212    212   
        Ok(())
  213    213   
    }
  214    214   
}
  215    215   
impl RouteServerEndpoint {
  216    216   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  217         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  218         -
        deserializer: &mut D,
         217  +
    pub fn deserialize(
         218  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  219    219   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  220    220   
        #[allow(unused_variables, unused_mut)]
  221    221   
        let mut builder = Self::builder();
  222    222   
        #[allow(
  223    223   
            unused_variables,
  224    224   
            unreachable_code,
  225    225   
            clippy::single_match,
  226    226   
            clippy::match_single_binding,
  227    227   
            clippy::diverging_sub_expression
  228    228   
        )]
  229         -
        deserializer.read_struct(&ROUTESERVERENDPOINT_SCHEMA, (), |_, member, deser| {
         229  +
        deserializer.read_struct(&ROUTESERVERENDPOINT_SCHEMA, &mut |member, deser| {
  230    230   
            match member.member_index() {
  231    231   
                Some(0) => {
  232    232   
                    builder.route_server_id = Some(deser.read_string(member)?);
  233    233   
                }
  234    234   
                Some(1) => {
  235    235   
                    builder.route_server_endpoint_id = Some(deser.read_string(member)?);
  236    236   
                }
  237    237   
                Some(2) => {
  238    238   
                    builder.vpc_id = Some(deser.read_string(member)?);
  239    239   
                }
  240    240   
                Some(3) => {
  241    241   
                    builder.subnet_id = Some(deser.read_string(member)?);
  242    242   
                }
  243    243   
                Some(4) => {
  244    244   
                    builder.eni_id = Some(deser.read_string(member)?);
  245    245   
                }
  246    246   
                Some(5) => {
  247    247   
                    builder.eni_address = Some(deser.read_string(member)?);
  248    248   
                }
  249    249   
                Some(6) => {
  250    250   
                    builder.state = Some(crate::types::RouteServerEndpointState::from(deser.read_string(member)?.as_str()));
  251    251   
                }
  252    252   
                Some(7) => {
  253    253   
                    builder.failure_reason = Some(deser.read_string(member)?);
  254    254   
                }
  255    255   
                Some(8) => {
  256    256   
                    builder.tags = Some({
  257         -
                        let container = if let Some(cap) = deser.container_size() {
  258         -
                            Vec::with_capacity(cap)
  259         -
                        } else {
  260         -
                            Vec::new()
  261         -
                        };
  262         -
                        deser.read_list(member, container, |mut list, deser| {
  263         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  264         -
                            Ok(list)
  265         -
                        })?
         257  +
                        let mut container = Vec::new();
         258  +
                        deser.read_list(member, &mut |deser| {
         259  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         260  +
                            Ok(())
         261  +
                        })?;
         262  +
                        container
  266    263   
                    });
  267    264   
                }
  268    265   
                _ => {}
  269    266   
            }
  270    267   
            Ok(())
  271    268   
        })?;
  272    269   
        Ok(builder.build())
  273    270   
    }
  274    271   
}
         272  +
impl RouteServerEndpoint {
         273  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         274  +
    pub fn deserialize_with_response(
         275  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         276  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         277  +
        _status: u16,
         278  +
        _body: &[u8],
         279  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         280  +
        Self::deserialize(deserializer)
         281  +
    }
         282  +
}
  275    283   
impl RouteServerEndpoint {
  276    284   
    /// Creates a new builder-style object to manufacture [`RouteServerEndpoint`](crate::types::RouteServerEndpoint).
  277    285   
    pub fn builder() -> crate::types::builders::RouteServerEndpointBuilder {
  278    286   
        crate::types::builders::RouteServerEndpointBuilder::default()
  279    287   
    }
  280    288   
}
  281    289   
  282    290   
/// A builder for [`RouteServerEndpoint`](crate::types::RouteServerEndpoint).
  283    291   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  284    292   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_peer.rs

@@ -84,84 +243,243 @@
  104    104   
}
  105    105   
static ROUTESERVERPEER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  106    106   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer", "com.amazonaws.ec2", "RouteServerPeer");
  107    107   
static ROUTESERVERPEER_MEMBER_ROUTE_SERVER_PEER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.ec2#RouteServerPeer$RouteServerPeerId",
  110    110   
        "com.amazonaws.ec2",
  111    111   
        "RouteServerPeer",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "route_server_peer_id",
         114  +
    "RouteServerPeerId",
  115    115   
    0,
  116    116   
)
  117    117   
.with_xml_name("routeServerPeerId");
  118    118   
static ROUTESERVERPEER_MEMBER_ROUTE_SERVER_ENDPOINT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.ec2#RouteServerPeer$RouteServerEndpointId",
  121    121   
        "com.amazonaws.ec2",
  122    122   
        "RouteServerPeer",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "route_server_endpoint_id",
         125  +
    "RouteServerEndpointId",
  126    126   
    1,
  127    127   
)
  128    128   
.with_xml_name("routeServerEndpointId");
  129    129   
static ROUTESERVERPEER_MEMBER_ROUTE_SERVER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  130    130   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$RouteServerId", "com.amazonaws.ec2", "RouteServerPeer"),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "route_server_id",
         132  +
    "RouteServerId",
  133    133   
    2,
  134    134   
)
  135    135   
.with_xml_name("routeServerId");
  136    136   
static ROUTESERVERPEER_MEMBER_VPC_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$VpcId", "com.amazonaws.ec2", "RouteServerPeer"),
  138    138   
    ::aws_smithy_schema::ShapeType::String,
  139         -
    "vpc_id",
         139  +
    "VpcId",
  140    140   
    3,
  141    141   
)
  142    142   
.with_xml_name("vpcId");
  143    143   
static ROUTESERVERPEER_MEMBER_SUBNET_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  144    144   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$SubnetId", "com.amazonaws.ec2", "RouteServerPeer"),
  145    145   
    ::aws_smithy_schema::ShapeType::String,
  146         -
    "subnet_id",
         146  +
    "SubnetId",
  147    147   
    4,
  148    148   
)
  149    149   
.with_xml_name("subnetId");
  150    150   
static ROUTESERVERPEER_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$State", "com.amazonaws.ec2", "RouteServerPeer"),
  152    152   
    ::aws_smithy_schema::ShapeType::String,
  153         -
    "state",
         153  +
    "State",
  154    154   
    5,
  155    155   
)
  156    156   
.with_xml_name("state");
  157    157   
static ROUTESERVERPEER_MEMBER_FAILURE_REASON: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  158    158   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$FailureReason", "com.amazonaws.ec2", "RouteServerPeer"),
  159    159   
    ::aws_smithy_schema::ShapeType::String,
  160         -
    "failure_reason",
         160  +
    "FailureReason",
  161    161   
    6,
  162    162   
)
  163    163   
.with_xml_name("failureReason");
  164    164   
static ROUTESERVERPEER_MEMBER_ENDPOINT_ENI_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  165    165   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$EndpointEniId", "com.amazonaws.ec2", "RouteServerPeer"),
  166    166   
    ::aws_smithy_schema::ShapeType::String,
  167         -
    "endpoint_eni_id",
         167  +
    "EndpointEniId",
  168    168   
    7,
  169    169   
)
  170    170   
.with_xml_name("endpointEniId");
  171    171   
static ROUTESERVERPEER_MEMBER_ENDPOINT_ENI_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  172    172   
    ::aws_smithy_schema::ShapeId::from_static(
  173    173   
        "com.amazonaws.ec2#RouteServerPeer$EndpointEniAddress",
  174    174   
        "com.amazonaws.ec2",
  175    175   
        "RouteServerPeer",
  176    176   
    ),
  177    177   
    ::aws_smithy_schema::ShapeType::String,
  178         -
    "endpoint_eni_address",
         178  +
    "EndpointEniAddress",
  179    179   
    8,
  180    180   
)
  181    181   
.with_xml_name("endpointEniAddress");
  182    182   
static ROUTESERVERPEER_MEMBER_PEER_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  183    183   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$PeerAddress", "com.amazonaws.ec2", "RouteServerPeer"),
  184    184   
    ::aws_smithy_schema::ShapeType::String,
  185         -
    "peer_address",
         185  +
    "PeerAddress",
  186    186   
    9,
  187    187   
)
  188    188   
.with_xml_name("peerAddress");
  189    189   
static ROUTESERVERPEER_MEMBER_BGP_OPTIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  190    190   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$BgpOptions", "com.amazonaws.ec2", "RouteServerPeer"),
  191    191   
    ::aws_smithy_schema::ShapeType::Structure,
  192         -
    "bgp_options",
         192  +
    "BgpOptions",
  193    193   
    10,
  194    194   
)
  195    195   
.with_xml_name("bgpOptions");
  196    196   
static ROUTESERVERPEER_MEMBER_BGP_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  197    197   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$BgpStatus", "com.amazonaws.ec2", "RouteServerPeer"),
  198    198   
    ::aws_smithy_schema::ShapeType::Structure,
  199         -
    "bgp_status",
         199  +
    "BgpStatus",
  200    200   
    11,
  201    201   
)
  202    202   
.with_xml_name("bgpStatus");
  203    203   
static ROUTESERVERPEER_MEMBER_BFD_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  204    204   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$BfdStatus", "com.amazonaws.ec2", "RouteServerPeer"),
  205    205   
    ::aws_smithy_schema::ShapeType::Structure,
  206         -
    "bfd_status",
         206  +
    "BfdStatus",
  207    207   
    12,
  208    208   
)
  209    209   
.with_xml_name("bfdStatus");
  210    210   
static ROUTESERVERPEER_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  211    211   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPeer$Tags", "com.amazonaws.ec2", "RouteServerPeer"),
  212    212   
    ::aws_smithy_schema::ShapeType::List,
  213         -
    "tags",
         213  +
    "Tags",
  214    214   
    13,
  215    215   
)
  216    216   
.with_xml_name("tagSet");
  217    217   
static ROUTESERVERPEER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  218    218   
    ROUTESERVERPEER_SCHEMA_ID,
  219    219   
    ::aws_smithy_schema::ShapeType::Structure,
  220    220   
    &[
  221    221   
        &ROUTESERVERPEER_MEMBER_ROUTE_SERVER_PEER_ID,
  222    222   
        &ROUTESERVERPEER_MEMBER_ROUTE_SERVER_ENDPOINT_ID,
  223    223   
        &ROUTESERVERPEER_MEMBER_ROUTE_SERVER_ID,
@@ -272,272 +404,412 @@
  292    292   
                    }
  293    293   
                    Ok(())
  294    294   
                },
  295    295   
            )?;
  296    296   
        }
  297    297   
        Ok(())
  298    298   
    }
  299    299   
}
  300    300   
impl RouteServerPeer {
  301    301   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  302         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  303         -
        deserializer: &mut D,
         302  +
    pub fn deserialize(
         303  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  304    304   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  305    305   
        #[allow(unused_variables, unused_mut)]
  306    306   
        let mut builder = Self::builder();
  307    307   
        #[allow(
  308    308   
            unused_variables,
  309    309   
            unreachable_code,
  310    310   
            clippy::single_match,
  311    311   
            clippy::match_single_binding,
  312    312   
            clippy::diverging_sub_expression
  313    313   
        )]
  314         -
        deserializer.read_struct(&ROUTESERVERPEER_SCHEMA, (), |_, member, deser| {
         314  +
        deserializer.read_struct(&ROUTESERVERPEER_SCHEMA, &mut |member, deser| {
  315    315   
            match member.member_index() {
  316    316   
                Some(0) => {
  317    317   
                    builder.route_server_peer_id = Some(deser.read_string(member)?);
  318    318   
                }
  319    319   
                Some(1) => {
  320    320   
                    builder.route_server_endpoint_id = Some(deser.read_string(member)?);
  321    321   
                }
  322    322   
                Some(2) => {
  323    323   
                    builder.route_server_id = Some(deser.read_string(member)?);
  324    324   
                }
  325    325   
                Some(3) => {
  326    326   
                    builder.vpc_id = Some(deser.read_string(member)?);
  327    327   
                }
  328    328   
                Some(4) => {
  329    329   
                    builder.subnet_id = Some(deser.read_string(member)?);
  330    330   
                }
  331    331   
                Some(5) => {
  332    332   
                    builder.state = Some(crate::types::RouteServerPeerState::from(deser.read_string(member)?.as_str()));
  333    333   
                }
  334    334   
                Some(6) => {
  335    335   
                    builder.failure_reason = Some(deser.read_string(member)?);
  336    336   
                }
  337    337   
                Some(7) => {
  338    338   
                    builder.endpoint_eni_id = Some(deser.read_string(member)?);
  339    339   
                }
  340    340   
                Some(8) => {
  341    341   
                    builder.endpoint_eni_address = Some(deser.read_string(member)?);
  342    342   
                }
  343    343   
                Some(9) => {
  344    344   
                    builder.peer_address = Some(deser.read_string(member)?);
  345    345   
                }
  346    346   
                Some(10) => {
  347    347   
                    builder.bgp_options = Some(crate::types::RouteServerBgpOptions::deserialize(deser)?);
  348    348   
                }
  349    349   
                Some(11) => {
  350    350   
                    builder.bgp_status = Some(crate::types::RouteServerBgpStatus::deserialize(deser)?);
  351    351   
                }
  352    352   
                Some(12) => {
  353    353   
                    builder.bfd_status = Some(crate::types::RouteServerBfdStatus::deserialize(deser)?);
  354    354   
                }
  355    355   
                Some(13) => {
  356    356   
                    builder.tags = Some({
  357         -
                        let container = if let Some(cap) = deser.container_size() {
  358         -
                            Vec::with_capacity(cap)
  359         -
                        } else {
  360         -
                            Vec::new()
  361         -
                        };
  362         -
                        deser.read_list(member, container, |mut list, deser| {
  363         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  364         -
                            Ok(list)
  365         -
                        })?
         357  +
                        let mut container = Vec::new();
         358  +
                        deser.read_list(member, &mut |deser| {
         359  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         360  +
                            Ok(())
         361  +
                        })?;
         362  +
                        container
  366    363   
                    });
  367    364   
                }
  368    365   
                _ => {}
  369    366   
            }
  370    367   
            Ok(())
  371    368   
        })?;
  372    369   
        Ok(builder.build())
  373    370   
    }
  374    371   
}
         372  +
impl RouteServerPeer {
         373  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         374  +
    pub fn deserialize_with_response(
         375  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         376  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         377  +
        _status: u16,
         378  +
        _body: &[u8],
         379  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         380  +
        Self::deserialize(deserializer)
         381  +
    }
         382  +
}
  375    383   
impl RouteServerPeer {
  376    384   
    /// Creates a new builder-style object to manufacture [`RouteServerPeer`](crate::types::RouteServerPeer).
  377    385   
    pub fn builder() -> crate::types::builders::RouteServerPeerBuilder {
  378    386   
        crate::types::builders::RouteServerPeerBuilder::default()
  379    387   
    }
  380    388   
}
  381    389   
  382    390   
/// A builder for [`RouteServerPeer`](crate::types::RouteServerPeer).
  383    391   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  384    392   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/ec2/src/types/_route_server_propagation.rs

@@ -8,8 +156,167 @@
   28     28   
}
   29     29   
static ROUTESERVERPROPAGATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   30     30   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#RouteServerPropagation", "com.amazonaws.ec2", "RouteServerPropagation");
   31     31   
static ROUTESERVERPROPAGATION_MEMBER_ROUTE_SERVER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   32     32   
    ::aws_smithy_schema::ShapeId::from_static(
   33     33   
        "com.amazonaws.ec2#RouteServerPropagation$RouteServerId",
   34     34   
        "com.amazonaws.ec2",
   35     35   
        "RouteServerPropagation",
   36     36   
    ),
   37     37   
    ::aws_smithy_schema::ShapeType::String,
   38         -
    "route_server_id",
          38  +
    "RouteServerId",
   39     39   
    0,
   40     40   
)
   41     41   
.with_xml_name("routeServerId");
   42     42   
static ROUTESERVERPROPAGATION_MEMBER_ROUTE_TABLE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static(
   44     44   
        "com.amazonaws.ec2#RouteServerPropagation$RouteTableId",
   45     45   
        "com.amazonaws.ec2",
   46     46   
        "RouteServerPropagation",
   47     47   
    ),
   48     48   
    ::aws_smithy_schema::ShapeType::String,
   49         -
    "route_table_id",
          49  +
    "RouteTableId",
   50     50   
    1,
   51     51   
)
   52     52   
.with_xml_name("routeTableId");
   53     53   
static ROUTESERVERPROPAGATION_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#RouteServerPropagation$State",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "RouteServerPropagation",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::String,
   60         -
    "state",
          60  +
    "State",
   61     61   
    2,
   62     62   
)
   63     63   
.with_xml_name("state");
   64     64   
static ROUTESERVERPROPAGATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   65     65   
    ROUTESERVERPROPAGATION_SCHEMA_ID,
   66     66   
    ::aws_smithy_schema::ShapeType::Structure,
   67     67   
    &[
   68     68   
        &ROUTESERVERPROPAGATION_MEMBER_ROUTE_SERVER_ID,
   69     69   
        &ROUTESERVERPROPAGATION_MEMBER_ROUTE_TABLE_ID,
   70     70   
        &ROUTESERVERPROPAGATION_MEMBER_STATE,
   71     71   
    ],
   72     72   
);
   73     73   
impl RouteServerPropagation {
   74     74   
    /// The schema for this shape.
   75     75   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &ROUTESERVERPROPAGATION_SCHEMA;
   76     76   
}
   77     77   
impl ::aws_smithy_schema::serde::SerializableStruct for RouteServerPropagation {
   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.route_server_id {
   84     84   
            ser.write_string(&ROUTESERVERPROPAGATION_MEMBER_ROUTE_SERVER_ID, val)?;
   85     85   
        }
   86     86   
        if let Some(ref val) = self.route_table_id {
   87     87   
            ser.write_string(&ROUTESERVERPROPAGATION_MEMBER_ROUTE_TABLE_ID, val)?;
   88     88   
        }
   89     89   
        if let Some(ref val) = self.state {
   90     90   
            ser.write_string(&ROUTESERVERPROPAGATION_MEMBER_STATE, val.as_str())?;
   91     91   
        }
   92     92   
        Ok(())
   93     93   
    }
   94     94   
}
   95     95   
impl RouteServerPropagation {
   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(&ROUTESERVERPROPAGATION_SCHEMA, (), |_, member, deser| {
         109  +
        deserializer.read_struct(&ROUTESERVERPROPAGATION_SCHEMA, &mut |member, deser| {
  110    110   
            match member.member_index() {
  111    111   
                Some(0) => {
  112    112   
                    builder.route_server_id = Some(deser.read_string(member)?);
  113    113   
                }
  114    114   
                Some(1) => {
  115    115   
                    builder.route_table_id = Some(deser.read_string(member)?);
  116    116   
                }
  117    117   
                Some(2) => {
  118    118   
                    builder.state = Some(crate::types::RouteServerPropagationState::from(deser.read_string(member)?.as_str()));
  119    119   
                }
  120    120   
                _ => {}
  121    121   
            }
  122    122   
            Ok(())
  123    123   
        })?;
  124    124   
        Ok(builder.build())
  125    125   
    }
  126    126   
}
         127  +
impl RouteServerPropagation {
         128  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         129  +
    pub fn deserialize_with_response(
         130  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         131  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         132  +
        _status: u16,
         133  +
        _body: &[u8],
         134  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         135  +
        Self::deserialize(deserializer)
         136  +
    }
         137  +
}
  127    138   
impl RouteServerPropagation {
  128    139   
    /// Creates a new builder-style object to manufacture [`RouteServerPropagation`](crate::types::RouteServerPropagation).
  129    140   
    pub fn builder() -> crate::types::builders::RouteServerPropagationBuilder {
  130    141   
        crate::types::builders::RouteServerPropagationBuilder::default()
  131    142   
    }
  132    143   
}
  133    144   
  134    145   
/// A builder for [`RouteServerPropagation`](crate::types::RouteServerPropagation).
  135    146   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  136    147   
#[non_exhaustive]