AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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

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

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

@@ -13,13 +167,178 @@
   33     33   
}
   34     34   
static CREATEFLEETERROR_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CreateFleetError", "com.amazonaws.ec2", "CreateFleetError");
   36     36   
static CREATEFLEETERROR_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static(
   38     38   
        "com.amazonaws.ec2#CreateFleetError$LaunchTemplateAndOverrides",
   39     39   
        "com.amazonaws.ec2",
   40     40   
        "CreateFleetError",
   41     41   
    ),
   42     42   
    ::aws_smithy_schema::ShapeType::Structure,
   43         -
    "launch_template_and_overrides",
          43  +
    "LaunchTemplateAndOverrides",
   44     44   
    0,
   45     45   
)
   46     46   
.with_xml_name("launchTemplateAndOverrides");
   47     47   
static CREATEFLEETERROR_MEMBER_LIFECYCLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CreateFleetError$Lifecycle", "com.amazonaws.ec2", "CreateFleetError"),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "lifecycle",
          50  +
    "Lifecycle",
   51     51   
    1,
   52     52   
)
   53     53   
.with_xml_name("lifecycle");
   54     54   
static CREATEFLEETERROR_MEMBER_ERROR_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CreateFleetError$ErrorCode", "com.amazonaws.ec2", "CreateFleetError"),
   56     56   
    ::aws_smithy_schema::ShapeType::String,
   57         -
    "error_code",
          57  +
    "ErrorCode",
   58     58   
    2,
   59     59   
)
   60     60   
.with_xml_name("errorCode");
   61     61   
static CREATEFLEETERROR_MEMBER_ERROR_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CreateFleetError$ErrorMessage", "com.amazonaws.ec2", "CreateFleetError"),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "error_message",
          64  +
    "ErrorMessage",
   65     65   
    3,
   66     66   
)
   67     67   
.with_xml_name("errorMessage");
   68     68   
static CREATEFLEETERROR_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   69     69   
    CREATEFLEETERROR_SCHEMA_ID,
   70     70   
    ::aws_smithy_schema::ShapeType::Structure,
   71     71   
    &[
   72     72   
        &CREATEFLEETERROR_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES,
   73     73   
        &CREATEFLEETERROR_MEMBER_LIFECYCLE,
   74     74   
        &CREATEFLEETERROR_MEMBER_ERROR_CODE,
   75     75   
        &CREATEFLEETERROR_MEMBER_ERROR_MESSAGE,
   76     76   
    ],
   77     77   
);
   78     78   
impl CreateFleetError {
   79     79   
    /// The schema for this shape.
   80     80   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEFLEETERROR_SCHEMA;
   81     81   
}
   82     82   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateFleetError {
   83     83   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   84     84   
    fn serialize_members(
   85     85   
        &self,
   86     86   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   87     87   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   88     88   
        if let Some(ref val) = self.launch_template_and_overrides {
   89     89   
            ser.write_struct(&CREATEFLEETERROR_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES, val)?;
   90     90   
        }
   91     91   
        if let Some(ref val) = self.lifecycle {
   92     92   
            ser.write_string(&CREATEFLEETERROR_MEMBER_LIFECYCLE, val.as_str())?;
   93     93   
        }
   94     94   
        if let Some(ref val) = self.error_code {
   95     95   
            ser.write_string(&CREATEFLEETERROR_MEMBER_ERROR_CODE, val)?;
   96     96   
        }
   97     97   
        if let Some(ref val) = self.error_message {
   98     98   
            ser.write_string(&CREATEFLEETERROR_MEMBER_ERROR_MESSAGE, val)?;
   99     99   
        }
  100    100   
        Ok(())
  101    101   
    }
  102    102   
}
  103    103   
impl CreateFleetError {
  104    104   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  105         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  106         -
        deserializer: &mut D,
         105  +
    pub fn deserialize(
         106  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  107    107   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  108    108   
        #[allow(unused_variables, unused_mut)]
  109    109   
        let mut builder = Self::builder();
  110    110   
        #[allow(
  111    111   
            unused_variables,
  112    112   
            unreachable_code,
  113    113   
            clippy::single_match,
  114    114   
            clippy::match_single_binding,
  115    115   
            clippy::diverging_sub_expression
  116    116   
        )]
  117         -
        deserializer.read_struct(&CREATEFLEETERROR_SCHEMA, (), |_, member, deser| {
         117  +
        deserializer.read_struct(&CREATEFLEETERROR_SCHEMA, &mut |member, deser| {
  118    118   
            match member.member_index() {
  119    119   
                Some(0) => {
  120    120   
                    builder.launch_template_and_overrides = Some(crate::types::LaunchTemplateAndOverridesResponse::deserialize(deser)?);
  121    121   
                }
  122    122   
                Some(1) => {
  123    123   
                    builder.lifecycle = Some(crate::types::InstanceLifecycle::from(deser.read_string(member)?.as_str()));
  124    124   
                }
  125    125   
                Some(2) => {
  126    126   
                    builder.error_code = Some(deser.read_string(member)?);
  127    127   
                }
  128    128   
                Some(3) => {
  129    129   
                    builder.error_message = Some(deser.read_string(member)?);
  130    130   
                }
  131    131   
                _ => {}
  132    132   
            }
  133    133   
            Ok(())
  134    134   
        })?;
  135    135   
        Ok(builder.build())
  136    136   
    }
  137    137   
}
         138  +
impl CreateFleetError {
         139  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         140  +
    pub fn deserialize_with_response(
         141  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         142  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         143  +
        _status: u16,
         144  +
        _body: &[u8],
         145  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         146  +
        Self::deserialize(deserializer)
         147  +
    }
         148  +
}
  138    149   
impl CreateFleetError {
  139    150   
    /// Creates a new builder-style object to manufacture [`CreateFleetError`](crate::types::CreateFleetError).
  140    151   
    pub fn builder() -> crate::types::builders::CreateFleetErrorBuilder {
  141    152   
        crate::types::builders::CreateFleetErrorBuilder::default()
  142    153   
    }
  143    154   
}
  144    155   
  145    156   
/// A builder for [`CreateFleetError`](crate::types::CreateFleetError).
  146    157   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  147    158   
#[non_exhaustive]

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

@@ -21,21 +223,224 @@
   41     41   
}
   42     42   
static CREATEFLEETINSTANCE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.ec2#CreateFleetInstance", "com.amazonaws.ec2", "CreateFleetInstance");
   44     44   
static CREATEFLEETINSTANCE_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.ec2#CreateFleetInstance$LaunchTemplateAndOverrides",
   47     47   
        "com.amazonaws.ec2",
   48     48   
        "CreateFleetInstance",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51         -
    "launch_template_and_overrides",
          51  +
    "LaunchTemplateAndOverrides",
   52     52   
    0,
   53     53   
)
   54     54   
.with_xml_name("launchTemplateAndOverrides");
   55     55   
static CREATEFLEETINSTANCE_MEMBER_LIFECYCLE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.ec2#CreateFleetInstance$Lifecycle",
   58     58   
        "com.amazonaws.ec2",
   59     59   
        "CreateFleetInstance",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "lifecycle",
          62  +
    "Lifecycle",
   63     63   
    1,
   64     64   
)
   65     65   
.with_xml_name("lifecycle");
   66     66   
static CREATEFLEETINSTANCE_MEMBER_INSTANCE_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.ec2#CreateFleetInstance$InstanceIds",
   69     69   
        "com.amazonaws.ec2",
   70     70   
        "CreateFleetInstance",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::List,
   73         -
    "instance_ids",
          73  +
    "InstanceIds",
   74     74   
    2,
   75     75   
)
   76     76   
.with_xml_name("instanceIds");
   77     77   
static CREATEFLEETINSTANCE_MEMBER_INSTANCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.ec2#CreateFleetInstance$InstanceType",
   80     80   
        "com.amazonaws.ec2",
   81     81   
        "CreateFleetInstance",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "instance_type",
          84  +
    "InstanceType",
   85     85   
    3,
   86     86   
)
   87     87   
.with_xml_name("instanceType");
   88     88   
static CREATEFLEETINSTANCE_MEMBER_PLATFORM: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#CreateFleetInstance$Platform",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "CreateFleetInstance",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "platform",
          95  +
    "Platform",
   96     96   
    4,
   97     97   
)
   98     98   
.with_xml_name("platform");
   99     99   
static CREATEFLEETINSTANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  100    100   
    CREATEFLEETINSTANCE_SCHEMA_ID,
  101    101   
    ::aws_smithy_schema::ShapeType::Structure,
  102    102   
    &[
  103    103   
        &CREATEFLEETINSTANCE_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES,
  104    104   
        &CREATEFLEETINSTANCE_MEMBER_LIFECYCLE,
  105    105   
        &CREATEFLEETINSTANCE_MEMBER_INSTANCE_IDS,
  106    106   
        &CREATEFLEETINSTANCE_MEMBER_INSTANCE_TYPE,
  107    107   
        &CREATEFLEETINSTANCE_MEMBER_PLATFORM,
  108    108   
    ],
  109    109   
);
  110    110   
impl CreateFleetInstance {
  111    111   
    /// The schema for this shape.
  112    112   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEFLEETINSTANCE_SCHEMA;
  113    113   
}
  114    114   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateFleetInstance {
  115    115   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  116    116   
    fn serialize_members(
  117    117   
        &self,
  118    118   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  119    119   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  120    120   
        if let Some(ref val) = self.launch_template_and_overrides {
  121    121   
            ser.write_struct(&CREATEFLEETINSTANCE_MEMBER_LAUNCH_TEMPLATE_AND_OVERRIDES, val)?;
  122    122   
        }
  123    123   
        if let Some(ref val) = self.lifecycle {
  124    124   
            ser.write_string(&CREATEFLEETINSTANCE_MEMBER_LIFECYCLE, val.as_str())?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.instance_ids {
  127    127   
            ser.write_list(
  128    128   
                &CREATEFLEETINSTANCE_MEMBER_INSTANCE_IDS,
  129    129   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  130    130   
                    for item in val {
  131    131   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  132    132   
                    }
  133    133   
                    Ok(())
  134    134   
                },
  135    135   
            )?;
  136    136   
        }
  137    137   
        if let Some(ref val) = self.instance_type {
  138    138   
            ser.write_string(&CREATEFLEETINSTANCE_MEMBER_INSTANCE_TYPE, val.as_str())?;
  139    139   
        }
  140    140   
        if let Some(ref val) = self.platform {
  141    141   
            ser.write_string(&CREATEFLEETINSTANCE_MEMBER_PLATFORM, val.as_str())?;
  142    142   
        }
  143    143   
        Ok(())
  144    144   
    }
  145    145   
}
  146    146   
impl CreateFleetInstance {
  147    147   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  148         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  149         -
        deserializer: &mut D,
         148  +
    pub fn deserialize(
         149  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  150    150   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  151    151   
        #[allow(unused_variables, unused_mut)]
  152    152   
        let mut builder = Self::builder();
  153    153   
        #[allow(
  154    154   
            unused_variables,
  155    155   
            unreachable_code,
  156    156   
            clippy::single_match,
  157    157   
            clippy::match_single_binding,
  158    158   
            clippy::diverging_sub_expression
  159    159   
        )]
  160         -
        deserializer.read_struct(&CREATEFLEETINSTANCE_SCHEMA, (), |_, member, deser| {
         160  +
        deserializer.read_struct(&CREATEFLEETINSTANCE_SCHEMA, &mut |member, deser| {
  161    161   
            match member.member_index() {
  162    162   
                Some(0) => {
  163    163   
                    builder.launch_template_and_overrides = Some(crate::types::LaunchTemplateAndOverridesResponse::deserialize(deser)?);
  164    164   
                }
  165    165   
                Some(1) => {
  166    166   
                    builder.lifecycle = Some(crate::types::InstanceLifecycle::from(deser.read_string(member)?.as_str()));
  167    167   
                }
  168    168   
                Some(2) => {
  169         -
                    builder.instance_ids = Some({
  170         -
                        let container = if let Some(cap) = deser.container_size() {
  171         -
                            Vec::with_capacity(cap)
  172         -
                        } else {
  173         -
                            Vec::new()
  174         -
                        };
  175         -
                        deser.read_list(member, container, |mut list, deser| {
  176         -
                            list.push(deser.read_string(member)?);
  177         -
                            Ok(list)
  178         -
                        })?
  179         -
                    });
         169  +
                    builder.instance_ids = Some(deser.read_string_list(member)?);
  180    170   
                }
  181    171   
                Some(3) => {
  182    172   
                    builder.instance_type = Some(crate::types::InstanceType::from(deser.read_string(member)?.as_str()));
  183    173   
                }
  184    174   
                Some(4) => {
  185    175   
                    builder.platform = Some(crate::types::PlatformValues::from(deser.read_string(member)?.as_str()));
  186    176   
                }
  187    177   
                _ => {}
  188    178   
            }
  189    179   
            Ok(())
  190    180   
        })?;
  191    181   
        Ok(builder.build())
  192    182   
    }
  193    183   
}
         184  +
impl CreateFleetInstance {
         185  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         186  +
    pub fn deserialize_with_response(
         187  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         188  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         189  +
        _status: u16,
         190  +
        _body: &[u8],
         191  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         192  +
        Self::deserialize(deserializer)
         193  +
    }
         194  +
}
  194    195   
impl CreateFleetInstance {
  195    196   
    /// Creates a new builder-style object to manufacture [`CreateFleetInstance`](crate::types::CreateFleetInstance).
  196    197   
    pub fn builder() -> crate::types::builders::CreateFleetInstanceBuilder {
  197    198   
        crate::types::builders::CreateFleetInstanceBuilder::default()
  198    199   
    }
  199    200   
}
  200    201   
  201    202   
/// A builder for [`CreateFleetInstance`](crate::types::CreateFleetInstance).
  202    203   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  203    204   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -20,20 +192,203 @@
   40     40   
    "com.amazonaws.ec2",
   41     41   
    "CreateTransitGatewayVpcAttachmentRequestOptions",
   42     42   
);
   43     43   
static CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_DNS_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.ec2#CreateTransitGatewayVpcAttachmentRequestOptions$DnsSupport",
   46     46   
        "com.amazonaws.ec2",
   47     47   
        "CreateTransitGatewayVpcAttachmentRequestOptions",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "dns_support",
          50  +
    "DnsSupport",
   51     51   
    0,
   52     52   
);
   53     53   
static CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_SECURITY_GROUP_REFERENCING_SUPPORT: ::aws_smithy_schema::Schema =
   54     54   
    ::aws_smithy_schema::Schema::new_member(
   55     55   
        ::aws_smithy_schema::ShapeId::from_static(
   56     56   
            "com.amazonaws.ec2#CreateTransitGatewayVpcAttachmentRequestOptions$SecurityGroupReferencingSupport",
   57     57   
            "com.amazonaws.ec2",
   58     58   
            "CreateTransitGatewayVpcAttachmentRequestOptions",
   59     59   
        ),
   60     60   
        ::aws_smithy_schema::ShapeType::String,
   61         -
        "security_group_referencing_support",
          61  +
        "SecurityGroupReferencingSupport",
   62     62   
        1,
   63     63   
    );
   64     64   
static CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_IPV6_SUPPORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.ec2#CreateTransitGatewayVpcAttachmentRequestOptions$Ipv6Support",
   67     67   
        "com.amazonaws.ec2",
   68     68   
        "CreateTransitGatewayVpcAttachmentRequestOptions",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "ipv6_support",
          71  +
    "Ipv6Support",
   72     72   
    2,
   73     73   
);
   74     74   
static CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_APPLIANCE_MODE_SUPPORT: ::aws_smithy_schema::Schema =
   75     75   
    ::aws_smithy_schema::Schema::new_member(
   76     76   
        ::aws_smithy_schema::ShapeId::from_static(
   77     77   
            "com.amazonaws.ec2#CreateTransitGatewayVpcAttachmentRequestOptions$ApplianceModeSupport",
   78     78   
            "com.amazonaws.ec2",
   79     79   
            "CreateTransitGatewayVpcAttachmentRequestOptions",
   80     80   
        ),
   81     81   
        ::aws_smithy_schema::ShapeType::String,
   82         -
        "appliance_mode_support",
          82  +
        "ApplianceModeSupport",
   83     83   
        3,
   84     84   
    );
   85     85   
static CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   86     86   
    CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_SCHEMA_ID,
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88     88   
    &[
   89     89   
        &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_DNS_SUPPORT,
   90     90   
        &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_SECURITY_GROUP_REFERENCING_SUPPORT,
   91     91   
        &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_IPV6_SUPPORT,
   92     92   
        &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_APPLIANCE_MODE_SUPPORT,
   93     93   
    ],
   94     94   
);
   95     95   
impl CreateTransitGatewayVpcAttachmentRequestOptions {
   96     96   
    /// The schema for this shape.
   97     97   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_SCHEMA;
   98     98   
}
   99     99   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateTransitGatewayVpcAttachmentRequestOptions {
  100    100   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  101    101   
    fn serialize_members(
  102    102   
        &self,
  103    103   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  104    104   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  105    105   
        if let Some(ref val) = self.dns_support {
  106    106   
            ser.write_string(&CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_DNS_SUPPORT, val.as_str())?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.security_group_referencing_support {
  109    109   
            ser.write_string(
  110    110   
                &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_SECURITY_GROUP_REFERENCING_SUPPORT,
  111    111   
                val.as_str(),
  112    112   
            )?;
  113    113   
        }
  114    114   
        if let Some(ref val) = self.ipv6_support {
  115    115   
            ser.write_string(&CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_IPV6_SUPPORT, val.as_str())?;
  116    116   
        }
  117    117   
        if let Some(ref val) = self.appliance_mode_support {
  118    118   
            ser.write_string(
  119    119   
                &CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_MEMBER_APPLIANCE_MODE_SUPPORT,
  120    120   
                val.as_str(),
  121    121   
            )?;
  122    122   
        }
  123    123   
        Ok(())
  124    124   
    }
  125    125   
}
  126    126   
impl CreateTransitGatewayVpcAttachmentRequestOptions {
  127    127   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  128         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  129         -
        deserializer: &mut D,
         128  +
    pub fn deserialize(
         129  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  130    130   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  131    131   
        #[allow(unused_variables, unused_mut)]
  132    132   
        let mut builder = Self::builder();
  133    133   
        #[allow(
  134    134   
            unused_variables,
  135    135   
            unreachable_code,
  136    136   
            clippy::single_match,
  137    137   
            clippy::match_single_binding,
  138    138   
            clippy::diverging_sub_expression
  139    139   
        )]
  140         -
        deserializer.read_struct(&CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_SCHEMA, (), |_, member, deser| {
         140  +
        deserializer.read_struct(&CREATETRANSITGATEWAYVPCATTACHMENTREQUESTOPTIONS_SCHEMA, &mut |member, deser| {
  141    141   
            match member.member_index() {
  142    142   
                Some(0) => {
  143    143   
                    builder.dns_support = Some(crate::types::DnsSupportValue::from(deser.read_string(member)?.as_str()));
  144    144   
                }
  145    145   
                Some(1) => {
  146    146   
                    builder.security_group_referencing_support = Some(crate::types::SecurityGroupReferencingSupportValue::from(
  147    147   
                        deser.read_string(member)?.as_str(),
  148    148   
                    ));
  149    149   
                }
  150    150   
                Some(2) => {
  151    151   
                    builder.ipv6_support = Some(crate::types::Ipv6SupportValue::from(deser.read_string(member)?.as_str()));
  152    152   
                }
  153    153   
                Some(3) => {
  154    154   
                    builder.appliance_mode_support = Some(crate::types::ApplianceModeSupportValue::from(deser.read_string(member)?.as_str()));
  155    155   
                }
  156    156   
                _ => {}
  157    157   
            }
  158    158   
            Ok(())
  159    159   
        })?;
  160    160   
        Ok(builder.build())
  161    161   
    }
  162    162   
}
         163  +
impl CreateTransitGatewayVpcAttachmentRequestOptions {
         164  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         165  +
    pub fn deserialize_with_response(
         166  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         167  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         168  +
        _status: u16,
         169  +
        _body: &[u8],
         170  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         171  +
        Self::deserialize(deserializer)
         172  +
    }
         173  +
}
  163    174   
impl CreateTransitGatewayVpcAttachmentRequestOptions {
  164    175   
    /// Creates a new builder-style object to manufacture [`CreateTransitGatewayVpcAttachmentRequestOptions`](crate::types::CreateTransitGatewayVpcAttachmentRequestOptions).
  165    176   
    pub fn builder() -> crate::types::builders::CreateTransitGatewayVpcAttachmentRequestOptionsBuilder {
  166    177   
        crate::types::builders::CreateTransitGatewayVpcAttachmentRequestOptionsBuilder::default()
  167    178   
    }
  168    179   
}
  169    180   
  170    181   
/// A builder for [`CreateTransitGatewayVpcAttachmentRequestOptions`](crate::types::CreateTransitGatewayVpcAttachmentRequestOptions).
  171    182   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  172    183   
#[non_exhaustive]

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

@@ -20,20 +220,218 @@
   40     40   
    "com.amazonaws.ec2",
   41     41   
    "CreateVerifiedAccessEndpointCidrOptions",
   42     42   
);
   43     43   
static CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   44     44   
    ::aws_smithy_schema::ShapeId::from_static(
   45     45   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointCidrOptions$Protocol",
   46     46   
        "com.amazonaws.ec2",
   47     47   
        "CreateVerifiedAccessEndpointCidrOptions",
   48     48   
    ),
   49     49   
    ::aws_smithy_schema::ShapeType::String,
   50         -
    "protocol",
          50  +
    "Protocol",
   51     51   
    0,
   52     52   
);
   53     53   
static CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_SUBNET_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static(
   55     55   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointCidrOptions$SubnetIds",
   56     56   
        "com.amazonaws.ec2",
   57     57   
        "CreateVerifiedAccessEndpointCidrOptions",
   58     58   
    ),
   59     59   
    ::aws_smithy_schema::ShapeType::List,
   60         -
    "subnet_ids",
          60  +
    "SubnetIds",
   61     61   
    1,
   62     62   
)
   63     63   
.with_xml_name("SubnetId");
   64     64   
static CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_CIDR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static(
   66     66   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointCidrOptions$Cidr",
   67     67   
        "com.amazonaws.ec2",
   68     68   
        "CreateVerifiedAccessEndpointCidrOptions",
   69     69   
    ),
   70     70   
    ::aws_smithy_schema::ShapeType::String,
   71         -
    "cidr",
          71  +
    "Cidr",
   72     72   
    2,
   73     73   
);
   74     74   
static CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   75     75   
    ::aws_smithy_schema::ShapeId::from_static(
   76     76   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointCidrOptions$PortRanges",
   77     77   
        "com.amazonaws.ec2",
   78     78   
        "CreateVerifiedAccessEndpointCidrOptions",
   79     79   
    ),
   80     80   
    ::aws_smithy_schema::ShapeType::List,
   81         -
    "port_ranges",
          81  +
    "PortRanges",
   82     82   
    3,
   83     83   
)
   84     84   
.with_xml_name("PortRange");
   85     85   
static CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   86     86   
    CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_SCHEMA_ID,
   87     87   
    ::aws_smithy_schema::ShapeType::Structure,
   88     88   
    &[
   89     89   
        &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PROTOCOL,
   90     90   
        &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_SUBNET_IDS,
   91     91   
        &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_CIDR,
   92     92   
        &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PORT_RANGES,
   93     93   
    ],
   94     94   
);
   95     95   
impl CreateVerifiedAccessEndpointCidrOptions {
   96     96   
    /// The schema for this shape.
   97     97   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_SCHEMA;
   98     98   
}
   99     99   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessEndpointCidrOptions {
  100    100   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  101    101   
    fn serialize_members(
  102    102   
        &self,
  103    103   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  104    104   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  105    105   
        if let Some(ref val) = self.protocol {
  106    106   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PROTOCOL, val.as_str())?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.subnet_ids {
  109    109   
            ser.write_list(
  110    110   
                &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_SUBNET_IDS,
  111    111   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  112    112   
                    for item in val {
  113    113   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  114    114   
                    }
  115    115   
                    Ok(())
  116    116   
                },
  117    117   
            )?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.cidr {
  120    120   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_CIDR, val)?;
  121    121   
        }
  122    122   
        if let Some(ref val) = self.port_ranges {
  123    123   
            ser.write_list(
  124    124   
                &CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_MEMBER_PORT_RANGES,
  125    125   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  126    126   
                    for item in val {
  127    127   
                        ser.write_struct(crate::types::CreateVerifiedAccessEndpointPortRange::SCHEMA, item)?;
  128    128   
                    }
  129    129   
                    Ok(())
  130    130   
                },
  131    131   
            )?;
  132    132   
        }
  133    133   
        Ok(())
  134    134   
    }
  135    135   
}
  136    136   
impl CreateVerifiedAccessEndpointCidrOptions {
  137    137   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  138         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  139         -
        deserializer: &mut D,
         138  +
    pub fn deserialize(
         139  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  140    140   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  141    141   
        #[allow(unused_variables, unused_mut)]
  142    142   
        let mut builder = Self::builder();
  143    143   
        #[allow(
  144    144   
            unused_variables,
  145    145   
            unreachable_code,
  146    146   
            clippy::single_match,
  147    147   
            clippy::match_single_binding,
  148    148   
            clippy::diverging_sub_expression
  149    149   
        )]
  150         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_SCHEMA, (), |_, member, deser| {
         150  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTCIDROPTIONS_SCHEMA, &mut |member, deser| {
  151    151   
            match member.member_index() {
  152    152   
                Some(0) => {
  153    153   
                    builder.protocol = Some(crate::types::VerifiedAccessEndpointProtocol::from(deser.read_string(member)?.as_str()));
  154    154   
                }
  155    155   
                Some(1) => {
  156         -
                    builder.subnet_ids = Some({
  157         -
                        let container = if let Some(cap) = deser.container_size() {
  158         -
                            Vec::with_capacity(cap)
  159         -
                        } else {
  160         -
                            Vec::new()
  161         -
                        };
  162         -
                        deser.read_list(member, container, |mut list, deser| {
  163         -
                            list.push(deser.read_string(member)?);
  164         -
                            Ok(list)
  165         -
                        })?
  166         -
                    });
         156  +
                    builder.subnet_ids = Some(deser.read_string_list(member)?);
  167    157   
                }
  168    158   
                Some(2) => {
  169    159   
                    builder.cidr = Some(deser.read_string(member)?);
  170    160   
                }
  171    161   
                Some(3) => {
  172    162   
                    builder.port_ranges = Some({
  173         -
                        let container = if let Some(cap) = deser.container_size() {
  174         -
                            Vec::with_capacity(cap)
  175         -
                        } else {
  176         -
                            Vec::new()
  177         -
                        };
  178         -
                        deser.read_list(member, container, |mut list, deser| {
  179         -
                            list.push(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
  180         -
                            Ok(list)
  181         -
                        })?
         163  +
                        let mut container = Vec::new();
         164  +
                        deser.read_list(member, &mut |deser| {
         165  +
                            container.push(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
         166  +
                            Ok(())
         167  +
                        })?;
         168  +
                        container
  182    169   
                    });
  183    170   
                }
  184    171   
                _ => {}
  185    172   
            }
  186    173   
            Ok(())
  187    174   
        })?;
  188    175   
        Ok(builder.build())
  189    176   
    }
  190    177   
}
         178  +
impl CreateVerifiedAccessEndpointCidrOptions {
         179  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         180  +
    pub fn deserialize_with_response(
         181  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         182  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         183  +
        _status: u16,
         184  +
        _body: &[u8],
         185  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         186  +
        Self::deserialize(deserializer)
         187  +
    }
         188  +
}
  191    189   
impl CreateVerifiedAccessEndpointCidrOptions {
  192    190   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessEndpointCidrOptions`](crate::types::CreateVerifiedAccessEndpointCidrOptions).
  193    191   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessEndpointCidrOptionsBuilder {
  194    192   
        crate::types::builders::CreateVerifiedAccessEndpointCidrOptionsBuilder::default()
  195    193   
    }
  196    194   
}
  197    195   
  198    196   
/// A builder for [`CreateVerifiedAccessEndpointCidrOptions`](crate::types::CreateVerifiedAccessEndpointCidrOptions).
  199    197   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  200    198   
#[non_exhaustive]

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

@@ -18,18 +199,207 @@
   38     38   
    "com.amazonaws.ec2",
   39     39   
    "CreateVerifiedAccessEndpointEniOptions",
   40     40   
);
   41     41   
static CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_NETWORK_INTERFACE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   42     42   
    ::aws_smithy_schema::ShapeId::from_static(
   43     43   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointEniOptions$NetworkInterfaceId",
   44     44   
        "com.amazonaws.ec2",
   45     45   
        "CreateVerifiedAccessEndpointEniOptions",
   46     46   
    ),
   47     47   
    ::aws_smithy_schema::ShapeType::String,
   48         -
    "network_interface_id",
          48  +
    "NetworkInterfaceId",
   49     49   
    0,
   50     50   
);
   51     51   
static CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static(
   53     53   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointEniOptions$Protocol",
   54     54   
        "com.amazonaws.ec2",
   55     55   
        "CreateVerifiedAccessEndpointEniOptions",
   56     56   
    ),
   57     57   
    ::aws_smithy_schema::ShapeType::String,
   58         -
    "protocol",
          58  +
    "Protocol",
   59     59   
    1,
   60     60   
);
   61     61   
static CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointEniOptions$Port",
   64     64   
        "com.amazonaws.ec2",
   65     65   
        "CreateVerifiedAccessEndpointEniOptions",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Integer,
   68         -
    "port",
          68  +
    "Port",
   69     69   
    2,
   70     70   
);
   71     71   
static CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointEniOptions$PortRanges",
   74     74   
        "com.amazonaws.ec2",
   75     75   
        "CreateVerifiedAccessEndpointEniOptions",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::List,
   78         -
    "port_ranges",
          78  +
    "PortRanges",
   79     79   
    3,
   80     80   
)
   81     81   
.with_xml_name("PortRange");
   82     82   
static CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   83     83   
    CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_SCHEMA_ID,
   84     84   
    ::aws_smithy_schema::ShapeType::Structure,
   85     85   
    &[
   86     86   
        &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_NETWORK_INTERFACE_ID,
   87     87   
        &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PROTOCOL,
   88     88   
        &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT,
   89     89   
        &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT_RANGES,
   90     90   
    ],
   91     91   
);
   92     92   
impl CreateVerifiedAccessEndpointEniOptions {
   93     93   
    /// The schema for this shape.
   94     94   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_SCHEMA;
   95     95   
}
   96     96   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessEndpointEniOptions {
   97     97   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   98     98   
    fn serialize_members(
   99     99   
        &self,
  100    100   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  101    101   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  102    102   
        if let Some(ref val) = self.network_interface_id {
  103    103   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_NETWORK_INTERFACE_ID, val)?;
  104    104   
        }
  105    105   
        if let Some(ref val) = self.protocol {
  106    106   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PROTOCOL, val.as_str())?;
  107    107   
        }
  108    108   
        if let Some(ref val) = self.port {
  109    109   
            ser.write_integer(&CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT, *val)?;
  110    110   
        }
  111    111   
        if let Some(ref val) = self.port_ranges {
  112    112   
            ser.write_list(
  113    113   
                &CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_MEMBER_PORT_RANGES,
  114    114   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  115    115   
                    for item in val {
  116    116   
                        ser.write_struct(crate::types::CreateVerifiedAccessEndpointPortRange::SCHEMA, item)?;
  117    117   
                    }
  118    118   
                    Ok(())
  119    119   
                },
  120    120   
            )?;
  121    121   
        }
  122    122   
        Ok(())
  123    123   
    }
  124    124   
}
  125    125   
impl CreateVerifiedAccessEndpointEniOptions {
  126    126   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  127         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  128         -
        deserializer: &mut D,
         127  +
    pub fn deserialize(
         128  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  129    129   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  130    130   
        #[allow(unused_variables, unused_mut)]
  131    131   
        let mut builder = Self::builder();
  132    132   
        #[allow(
  133    133   
            unused_variables,
  134    134   
            unreachable_code,
  135    135   
            clippy::single_match,
  136    136   
            clippy::match_single_binding,
  137    137   
            clippy::diverging_sub_expression
  138    138   
        )]
  139         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_SCHEMA, (), |_, member, deser| {
         139  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTENIOPTIONS_SCHEMA, &mut |member, deser| {
  140    140   
            match member.member_index() {
  141    141   
                Some(0) => {
  142    142   
                    builder.network_interface_id = Some(deser.read_string(member)?);
  143    143   
                }
  144    144   
                Some(1) => {
  145    145   
                    builder.protocol = Some(crate::types::VerifiedAccessEndpointProtocol::from(deser.read_string(member)?.as_str()));
  146    146   
                }
  147    147   
                Some(2) => {
  148    148   
                    builder.port = Some(deser.read_integer(member)?);
  149    149   
                }
  150    150   
                Some(3) => {
  151    151   
                    builder.port_ranges = 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(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
  159         -
                            Ok(list)
  160         -
                        })?
         152  +
                        let mut container = Vec::new();
         153  +
                        deser.read_list(member, &mut |deser| {
         154  +
                            container.push(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
         155  +
                            Ok(())
         156  +
                        })?;
         157  +
                        container
  161    158   
                    });
  162    159   
                }
  163    160   
                _ => {}
  164    161   
            }
  165    162   
            Ok(())
  166    163   
        })?;
  167    164   
        Ok(builder.build())
  168    165   
    }
  169    166   
}
         167  +
impl CreateVerifiedAccessEndpointEniOptions {
         168  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         169  +
    pub fn deserialize_with_response(
         170  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         171  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         172  +
        _status: u16,
         173  +
        _body: &[u8],
         174  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         175  +
        Self::deserialize(deserializer)
         176  +
    }
         177  +
}
  170    178   
impl CreateVerifiedAccessEndpointEniOptions {
  171    179   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessEndpointEniOptions`](crate::types::CreateVerifiedAccessEndpointEniOptions).
  172    180   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessEndpointEniOptionsBuilder {
  173    181   
        crate::types::builders::CreateVerifiedAccessEndpointEniOptionsBuilder::default()
  174    182   
    }
  175    183   
}
  176    184   
  177    185   
/// A builder for [`CreateVerifiedAccessEndpointEniOptions`](crate::types::CreateVerifiedAccessEndpointEniOptions).
  178    186   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    187   
#[non_exhaustive]

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

@@ -26,26 +244,242 @@
   46     46   
    "com.amazonaws.ec2",
   47     47   
    "CreateVerifiedAccessEndpointLoadBalancerOptions",
   48     48   
);
   49     49   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   50     50   
    ::aws_smithy_schema::ShapeId::from_static(
   51     51   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointLoadBalancerOptions$Protocol",
   52     52   
        "com.amazonaws.ec2",
   53     53   
        "CreateVerifiedAccessEndpointLoadBalancerOptions",
   54     54   
    ),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "protocol",
          56  +
    "Protocol",
   57     57   
    0,
   58     58   
);
   59     59   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointLoadBalancerOptions$Port",
   62     62   
        "com.amazonaws.ec2",
   63     63   
        "CreateVerifiedAccessEndpointLoadBalancerOptions",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::Integer,
   66         -
    "port",
          66  +
    "Port",
   67     67   
    1,
   68     68   
);
   69     69   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_LOAD_BALANCER_ARN: ::aws_smithy_schema::Schema =
   70     70   
    ::aws_smithy_schema::Schema::new_member(
   71     71   
        ::aws_smithy_schema::ShapeId::from_static(
   72     72   
            "com.amazonaws.ec2#CreateVerifiedAccessEndpointLoadBalancerOptions$LoadBalancerArn",
   73     73   
            "com.amazonaws.ec2",
   74     74   
            "CreateVerifiedAccessEndpointLoadBalancerOptions",
   75     75   
        ),
   76     76   
        ::aws_smithy_schema::ShapeType::String,
   77         -
        "load_balancer_arn",
          77  +
        "LoadBalancerArn",
   78     78   
        2,
   79     79   
    );
   80     80   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_SUBNET_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointLoadBalancerOptions$SubnetIds",
   83     83   
        "com.amazonaws.ec2",
   84     84   
        "CreateVerifiedAccessEndpointLoadBalancerOptions",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::List,
   87         -
    "subnet_ids",
          87  +
    "SubnetIds",
   88     88   
    3,
   89     89   
)
   90     90   
.with_xml_name("SubnetId");
   91     91   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT_RANGES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointLoadBalancerOptions$PortRanges",
   94     94   
        "com.amazonaws.ec2",
   95     95   
        "CreateVerifiedAccessEndpointLoadBalancerOptions",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::List,
   98         -
    "port_ranges",
          98  +
    "PortRanges",
   99     99   
    4,
  100    100   
)
  101    101   
.with_xml_name("PortRange");
  102    102   
static CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  103    103   
    CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_SCHEMA_ID,
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105    105   
    &[
  106    106   
        &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PROTOCOL,
  107    107   
        &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT,
  108    108   
        &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_LOAD_BALANCER_ARN,
  109    109   
        &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_SUBNET_IDS,
  110    110   
        &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT_RANGES,
  111    111   
    ],
  112    112   
);
  113    113   
impl CreateVerifiedAccessEndpointLoadBalancerOptions {
  114    114   
    /// The schema for this shape.
  115    115   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_SCHEMA;
  116    116   
}
  117    117   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessEndpointLoadBalancerOptions {
  118    118   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  119    119   
    fn serialize_members(
  120    120   
        &self,
  121    121   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  122    122   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  123    123   
        if let Some(ref val) = self.protocol {
  124    124   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PROTOCOL, val.as_str())?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.port {
  127    127   
            ser.write_integer(&CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT, *val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.load_balancer_arn {
  130    130   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_LOAD_BALANCER_ARN, val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.subnet_ids {
  133    133   
            ser.write_list(
  134    134   
                &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_SUBNET_IDS,
  135    135   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  136    136   
                    for item in val {
  137    137   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  138    138   
                    }
  139    139   
                    Ok(())
  140    140   
                },
  141    141   
            )?;
  142    142   
        }
  143    143   
        if let Some(ref val) = self.port_ranges {
  144    144   
            ser.write_list(
  145    145   
                &CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_MEMBER_PORT_RANGES,
  146    146   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  147    147   
                    for item in val {
  148    148   
                        ser.write_struct(crate::types::CreateVerifiedAccessEndpointPortRange::SCHEMA, item)?;
  149    149   
                    }
  150    150   
                    Ok(())
  151    151   
                },
  152    152   
            )?;
  153    153   
        }
  154    154   
        Ok(())
  155    155   
    }
  156    156   
}
  157    157   
impl CreateVerifiedAccessEndpointLoadBalancerOptions {
  158    158   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  159         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  160         -
        deserializer: &mut D,
         159  +
    pub fn deserialize(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  161    161   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  162    162   
        #[allow(unused_variables, unused_mut)]
  163    163   
        let mut builder = Self::builder();
  164    164   
        #[allow(
  165    165   
            unused_variables,
  166    166   
            unreachable_code,
  167    167   
            clippy::single_match,
  168    168   
            clippy::match_single_binding,
  169    169   
            clippy::diverging_sub_expression
  170    170   
        )]
  171         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_SCHEMA, (), |_, member, deser| {
         171  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTLOADBALANCEROPTIONS_SCHEMA, &mut |member, deser| {
  172    172   
            match member.member_index() {
  173    173   
                Some(0) => {
  174    174   
                    builder.protocol = Some(crate::types::VerifiedAccessEndpointProtocol::from(deser.read_string(member)?.as_str()));
  175    175   
                }
  176    176   
                Some(1) => {
  177    177   
                    builder.port = Some(deser.read_integer(member)?);
  178    178   
                }
  179    179   
                Some(2) => {
  180    180   
                    builder.load_balancer_arn = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(3) => {
  183         -
                    builder.subnet_ids = Some({
  184         -
                        let container = if let Some(cap) = deser.container_size() {
  185         -
                            Vec::with_capacity(cap)
  186         -
                        } else {
  187         -
                            Vec::new()
  188         -
                        };
  189         -
                        deser.read_list(member, container, |mut list, deser| {
  190         -
                            list.push(deser.read_string(member)?);
  191         -
                            Ok(list)
  192         -
                        })?
  193         -
                    });
         183  +
                    builder.subnet_ids = Some(deser.read_string_list(member)?);
  194    184   
                }
  195    185   
                Some(4) => {
  196    186   
                    builder.port_ranges = Some({
  197         -
                        let container = if let Some(cap) = deser.container_size() {
  198         -
                            Vec::with_capacity(cap)
  199         -
                        } else {
  200         -
                            Vec::new()
  201         -
                        };
  202         -
                        deser.read_list(member, container, |mut list, deser| {
  203         -
                            list.push(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
  204         -
                            Ok(list)
  205         -
                        })?
         187  +
                        let mut container = Vec::new();
         188  +
                        deser.read_list(member, &mut |deser| {
         189  +
                            container.push(crate::types::CreateVerifiedAccessEndpointPortRange::deserialize(deser)?);
         190  +
                            Ok(())
         191  +
                        })?;
         192  +
                        container
  206    193   
                    });
  207    194   
                }
  208    195   
                _ => {}
  209    196   
            }
  210    197   
            Ok(())
  211    198   
        })?;
  212    199   
        Ok(builder.build())
  213    200   
    }
  214    201   
}
         202  +
impl CreateVerifiedAccessEndpointLoadBalancerOptions {
         203  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         204  +
    pub fn deserialize_with_response(
         205  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         206  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         207  +
        _status: u16,
         208  +
        _body: &[u8],
         209  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         210  +
        Self::deserialize(deserializer)
         211  +
    }
         212  +
}
  215    213   
impl CreateVerifiedAccessEndpointLoadBalancerOptions {
  216    214   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessEndpointLoadBalancerOptions`](crate::types::CreateVerifiedAccessEndpointLoadBalancerOptions).
  217    215   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessEndpointLoadBalancerOptionsBuilder {
  218    216   
        crate::types::builders::CreateVerifiedAccessEndpointLoadBalancerOptionsBuilder::default()
  219    217   
    }
  220    218   
}
  221    219   
  222    220   
/// A builder for [`CreateVerifiedAccessEndpointLoadBalancerOptions`](crate::types::CreateVerifiedAccessEndpointLoadBalancerOptions).
  223    221   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  224    222   
#[non_exhaustive]

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

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

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

@@ -36,36 +268,269 @@
   56     56   
    "com.amazonaws.ec2",
   57     57   
    "CreateVerifiedAccessEndpointRdsOptions",
   58     58   
);
   59     59   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PROTOCOL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static(
   61     61   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$Protocol",
   62     62   
        "com.amazonaws.ec2",
   63     63   
        "CreateVerifiedAccessEndpointRdsOptions",
   64     64   
    ),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "protocol",
          66  +
    "Protocol",
   67     67   
    0,
   68     68   
);
   69     69   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static(
   71     71   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$Port",
   72     72   
        "com.amazonaws.ec2",
   73     73   
        "CreateVerifiedAccessEndpointRdsOptions",
   74     74   
    ),
   75     75   
    ::aws_smithy_schema::ShapeType::Integer,
   76         -
    "port",
          76  +
    "Port",
   77     77   
    1,
   78     78   
);
   79     79   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_INSTANCE_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   80     80   
    ::aws_smithy_schema::ShapeId::from_static(
   81     81   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$RdsDbInstanceArn",
   82     82   
        "com.amazonaws.ec2",
   83     83   
        "CreateVerifiedAccessEndpointRdsOptions",
   84     84   
    ),
   85     85   
    ::aws_smithy_schema::ShapeType::String,
   86         -
    "rds_db_instance_arn",
          86  +
    "RdsDbInstanceArn",
   87     87   
    2,
   88     88   
);
   89     89   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_CLUSTER_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   90     90   
    ::aws_smithy_schema::ShapeId::from_static(
   91     91   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$RdsDbClusterArn",
   92     92   
        "com.amazonaws.ec2",
   93     93   
        "CreateVerifiedAccessEndpointRdsOptions",
   94     94   
    ),
   95     95   
    ::aws_smithy_schema::ShapeType::String,
   96         -
    "rds_db_cluster_arn",
          96  +
    "RdsDbClusterArn",
   97     97   
    3,
   98     98   
);
   99     99   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_PROXY_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  100    100   
    ::aws_smithy_schema::ShapeId::from_static(
  101    101   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$RdsDbProxyArn",
  102    102   
        "com.amazonaws.ec2",
  103    103   
        "CreateVerifiedAccessEndpointRdsOptions",
  104    104   
    ),
  105    105   
    ::aws_smithy_schema::ShapeType::String,
  106         -
    "rds_db_proxy_arn",
         106  +
    "RdsDbProxyArn",
  107    107   
    4,
  108    108   
);
  109    109   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$RdsEndpoint",
  112    112   
        "com.amazonaws.ec2",
  113    113   
        "CreateVerifiedAccessEndpointRdsOptions",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "rds_endpoint",
         116  +
    "RdsEndpoint",
  117    117   
    5,
  118    118   
);
  119    119   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_SUBNET_IDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  120    120   
    ::aws_smithy_schema::ShapeId::from_static(
  121    121   
        "com.amazonaws.ec2#CreateVerifiedAccessEndpointRdsOptions$SubnetIds",
  122    122   
        "com.amazonaws.ec2",
  123    123   
        "CreateVerifiedAccessEndpointRdsOptions",
  124    124   
    ),
  125    125   
    ::aws_smithy_schema::ShapeType::List,
  126         -
    "subnet_ids",
         126  +
    "SubnetIds",
  127    127   
    6,
  128    128   
)
  129    129   
.with_xml_name("SubnetId");
  130    130   
static CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  131    131   
    CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_SCHEMA_ID,
  132    132   
    ::aws_smithy_schema::ShapeType::Structure,
  133    133   
    &[
  134    134   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PROTOCOL,
  135    135   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PORT,
  136    136   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_INSTANCE_ARN,
  137    137   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_CLUSTER_ARN,
  138    138   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_PROXY_ARN,
  139    139   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_ENDPOINT,
  140    140   
        &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_SUBNET_IDS,
  141    141   
    ],
  142    142   
);
  143    143   
impl CreateVerifiedAccessEndpointRdsOptions {
  144    144   
    /// The schema for this shape.
  145    145   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_SCHEMA;
  146    146   
}
  147    147   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessEndpointRdsOptions {
  148    148   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  149    149   
    fn serialize_members(
  150    150   
        &self,
  151    151   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  152    152   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  153    153   
        if let Some(ref val) = self.protocol {
  154    154   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PROTOCOL, val.as_str())?;
  155    155   
        }
  156    156   
        if let Some(ref val) = self.port {
  157    157   
            ser.write_integer(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_PORT, *val)?;
  158    158   
        }
  159    159   
        if let Some(ref val) = self.rds_db_instance_arn {
  160    160   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_INSTANCE_ARN, val)?;
  161    161   
        }
  162    162   
        if let Some(ref val) = self.rds_db_cluster_arn {
  163    163   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_CLUSTER_ARN, val)?;
  164    164   
        }
  165    165   
        if let Some(ref val) = self.rds_db_proxy_arn {
  166    166   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_DB_PROXY_ARN, val)?;
  167    167   
        }
  168    168   
        if let Some(ref val) = self.rds_endpoint {
  169    169   
            ser.write_string(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_RDS_ENDPOINT, val)?;
  170    170   
        }
  171    171   
        if let Some(ref val) = self.subnet_ids {
  172    172   
            ser.write_list(
  173    173   
                &CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_MEMBER_SUBNET_IDS,
  174    174   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  175    175   
                    for item in val {
  176    176   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  177    177   
                    }
  178    178   
                    Ok(())
  179    179   
                },
  180    180   
            )?;
  181    181   
        }
  182    182   
        Ok(())
  183    183   
    }
  184    184   
}
  185    185   
impl CreateVerifiedAccessEndpointRdsOptions {
  186    186   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  187         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  188         -
        deserializer: &mut D,
         187  +
    pub fn deserialize(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  189    189   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  190    190   
        #[allow(unused_variables, unused_mut)]
  191    191   
        let mut builder = Self::builder();
  192    192   
        #[allow(
  193    193   
            unused_variables,
  194    194   
            unreachable_code,
  195    195   
            clippy::single_match,
  196    196   
            clippy::match_single_binding,
  197    197   
            clippy::diverging_sub_expression
  198    198   
        )]
  199         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_SCHEMA, (), |_, member, deser| {
         199  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSENDPOINTRDSOPTIONS_SCHEMA, &mut |member, deser| {
  200    200   
            match member.member_index() {
  201    201   
                Some(0) => {
  202    202   
                    builder.protocol = Some(crate::types::VerifiedAccessEndpointProtocol::from(deser.read_string(member)?.as_str()));
  203    203   
                }
  204    204   
                Some(1) => {
  205    205   
                    builder.port = Some(deser.read_integer(member)?);
  206    206   
                }
  207    207   
                Some(2) => {
  208    208   
                    builder.rds_db_instance_arn = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(3) => {
  211    211   
                    builder.rds_db_cluster_arn = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(4) => {
  214    214   
                    builder.rds_db_proxy_arn = Some(deser.read_string(member)?);
  215    215   
                }
  216    216   
                Some(5) => {
  217    217   
                    builder.rds_endpoint = Some(deser.read_string(member)?);
  218    218   
                }
  219    219   
                Some(6) => {
  220         -
                    builder.subnet_ids = Some({
  221         -
                        let container = if let Some(cap) = deser.container_size() {
  222         -
                            Vec::with_capacity(cap)
  223         -
                        } else {
  224         -
                            Vec::new()
  225         -
                        };
  226         -
                        deser.read_list(member, container, |mut list, deser| {
  227         -
                            list.push(deser.read_string(member)?);
  228         -
                            Ok(list)
  229         -
                        })?
  230         -
                    });
         220  +
                    builder.subnet_ids = Some(deser.read_string_list(member)?);
  231    221   
                }
  232    222   
                _ => {}
  233    223   
            }
  234    224   
            Ok(())
  235    225   
        })?;
  236    226   
        Ok(builder.build())
  237    227   
    }
  238    228   
}
         229  +
impl CreateVerifiedAccessEndpointRdsOptions {
         230  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         231  +
    pub fn deserialize_with_response(
         232  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         233  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         234  +
        _status: u16,
         235  +
        _body: &[u8],
         236  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         237  +
        Self::deserialize(deserializer)
         238  +
    }
         239  +
}
  239    240   
impl CreateVerifiedAccessEndpointRdsOptions {
  240    241   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessEndpointRdsOptions`](crate::types::CreateVerifiedAccessEndpointRdsOptions).
  241    242   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessEndpointRdsOptionsBuilder {
  242    243   
        crate::types::builders::CreateVerifiedAccessEndpointRdsOptionsBuilder::default()
  243    244   
    }
  244    245   
}
  245    246   
  246    247   
/// A builder for [`CreateVerifiedAccessEndpointRdsOptions`](crate::types::CreateVerifiedAccessEndpointRdsOptions).
  247    248   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  248    249   
#[non_exhaustive]

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

@@ -55,55 +287,298 @@
   75     75   
    "CreateVerifiedAccessNativeApplicationOidcOptions",
   76     76   
);
   77     77   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_PUBLIC_SIGNING_KEY_ENDPOINT: ::aws_smithy_schema::Schema =
   78     78   
    ::aws_smithy_schema::Schema::new_member(
   79     79   
        ::aws_smithy_schema::ShapeId::from_static(
   80     80   
            "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$PublicSigningKeyEndpoint",
   81     81   
            "com.amazonaws.ec2",
   82     82   
            "CreateVerifiedAccessNativeApplicationOidcOptions",
   83     83   
        ),
   84     84   
        ::aws_smithy_schema::ShapeType::String,
   85         -
        "public_signing_key_endpoint",
          85  +
        "PublicSigningKeyEndpoint",
   86     86   
        0,
   87     87   
    );
   88     88   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_ISSUER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$Issuer",
   91     91   
        "com.amazonaws.ec2",
   92     92   
        "CreateVerifiedAccessNativeApplicationOidcOptions",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "issuer",
          95  +
    "Issuer",
   96     96   
    1,
   97     97   
);
   98     98   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT: ::aws_smithy_schema::Schema =
   99     99   
    ::aws_smithy_schema::Schema::new_member(
  100    100   
        ::aws_smithy_schema::ShapeId::from_static(
  101    101   
            "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$AuthorizationEndpoint",
  102    102   
            "com.amazonaws.ec2",
  103    103   
            "CreateVerifiedAccessNativeApplicationOidcOptions",
  104    104   
        ),
  105    105   
        ::aws_smithy_schema::ShapeType::String,
  106         -
        "authorization_endpoint",
         106  +
        "AuthorizationEndpoint",
  107    107   
        2,
  108    108   
    );
  109    109   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_TOKEN_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  110    110   
    ::aws_smithy_schema::ShapeId::from_static(
  111    111   
        "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$TokenEndpoint",
  112    112   
        "com.amazonaws.ec2",
  113    113   
        "CreateVerifiedAccessNativeApplicationOidcOptions",
  114    114   
    ),
  115    115   
    ::aws_smithy_schema::ShapeType::String,
  116         -
    "token_endpoint",
         116  +
    "TokenEndpoint",
  117    117   
    3,
  118    118   
);
  119    119   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT: ::aws_smithy_schema::Schema =
  120    120   
    ::aws_smithy_schema::Schema::new_member(
  121    121   
        ::aws_smithy_schema::ShapeId::from_static(
  122    122   
            "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$UserInfoEndpoint",
  123    123   
            "com.amazonaws.ec2",
  124    124   
            "CreateVerifiedAccessNativeApplicationOidcOptions",
  125    125   
        ),
  126    126   
        ::aws_smithy_schema::ShapeType::String,
  127         -
        "user_info_endpoint",
         127  +
        "UserInfoEndpoint",
  128    128   
        4,
  129    129   
    );
  130    130   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  131    131   
    ::aws_smithy_schema::ShapeId::from_static(
  132    132   
        "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$ClientId",
  133    133   
        "com.amazonaws.ec2",
  134    134   
        "CreateVerifiedAccessNativeApplicationOidcOptions",
  135    135   
    ),
  136    136   
    ::aws_smithy_schema::ShapeType::String,
  137         -
    "client_id",
         137  +
    "ClientId",
  138    138   
    5,
  139    139   
);
  140    140   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  141    141   
    ::aws_smithy_schema::ShapeId::from_static(
  142    142   
        "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$ClientSecret",
  143    143   
        "com.amazonaws.ec2",
  144    144   
        "CreateVerifiedAccessNativeApplicationOidcOptions",
  145    145   
    ),
  146    146   
    ::aws_smithy_schema::ShapeType::String,
  147         -
    "client_secret",
         147  +
    "ClientSecret",
  148    148   
    6,
  149    149   
);
  150    150   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  151    151   
    ::aws_smithy_schema::ShapeId::from_static(
  152    152   
        "com.amazonaws.ec2#CreateVerifiedAccessNativeApplicationOidcOptions$Scope",
  153    153   
        "com.amazonaws.ec2",
  154    154   
        "CreateVerifiedAccessNativeApplicationOidcOptions",
  155    155   
    ),
  156    156   
    ::aws_smithy_schema::ShapeType::String,
  157         -
    "scope",
         157  +
    "Scope",
  158    158   
    7,
  159    159   
);
  160    160   
static CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  161    161   
    CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_SCHEMA_ID,
  162    162   
    ::aws_smithy_schema::ShapeType::Structure,
  163    163   
    &[
  164    164   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_PUBLIC_SIGNING_KEY_ENDPOINT,
  165    165   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_ISSUER,
  166    166   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT,
  167    167   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_TOKEN_ENDPOINT,
  168    168   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT,
  169    169   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_ID,
  170    170   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_SECRET,
  171    171   
        &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_SCOPE,
  172    172   
    ],
  173    173   
);
  174    174   
impl CreateVerifiedAccessNativeApplicationOidcOptions {
  175    175   
    /// The schema for this shape.
  176    176   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_SCHEMA;
  177    177   
}
  178    178   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessNativeApplicationOidcOptions {
  179    179   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  180    180   
    fn serialize_members(
  181    181   
        &self,
  182    182   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  183    183   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  184    184   
        if let Some(ref val) = self.public_signing_key_endpoint {
  185    185   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_PUBLIC_SIGNING_KEY_ENDPOINT, val)?;
  186    186   
        }
  187    187   
        if let Some(ref val) = self.issuer {
  188    188   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_ISSUER, val)?;
  189    189   
        }
  190    190   
        if let Some(ref val) = self.authorization_endpoint {
  191    191   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT, val)?;
  192    192   
        }
  193    193   
        if let Some(ref val) = self.token_endpoint {
  194    194   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_TOKEN_ENDPOINT, val)?;
  195    195   
        }
  196    196   
        if let Some(ref val) = self.user_info_endpoint {
  197    197   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT, val)?;
  198    198   
        }
  199    199   
        if let Some(ref val) = self.client_id {
  200    200   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_ID, val)?;
  201    201   
        }
  202    202   
        if let Some(ref val) = self.client_secret {
  203    203   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_CLIENT_SECRET, val)?;
  204    204   
        }
  205    205   
        if let Some(ref val) = self.scope {
  206    206   
            ser.write_string(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_MEMBER_SCOPE, val)?;
  207    207   
        }
  208    208   
        Ok(())
  209    209   
    }
  210    210   
}
  211    211   
impl CreateVerifiedAccessNativeApplicationOidcOptions {
  212    212   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  213         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  214         -
        deserializer: &mut D,
         213  +
    pub fn deserialize(
         214  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  215    215   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  216    216   
        #[allow(unused_variables, unused_mut)]
  217    217   
        let mut builder = Self::builder();
  218    218   
        #[allow(
  219    219   
            unused_variables,
  220    220   
            unreachable_code,
  221    221   
            clippy::single_match,
  222    222   
            clippy::match_single_binding,
  223    223   
            clippy::diverging_sub_expression
  224    224   
        )]
  225         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_SCHEMA, (), |_, member, deser| {
         225  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSNATIVEAPPLICATIONOIDCOPTIONS_SCHEMA, &mut |member, deser| {
  226    226   
            match member.member_index() {
  227    227   
                Some(0) => {
  228    228   
                    builder.public_signing_key_endpoint = Some(deser.read_string(member)?);
  229    229   
                }
  230    230   
                Some(1) => {
  231    231   
                    builder.issuer = Some(deser.read_string(member)?);
  232    232   
                }
  233    233   
                Some(2) => {
  234    234   
                    builder.authorization_endpoint = Some(deser.read_string(member)?);
  235    235   
                }
  236    236   
                Some(3) => {
  237    237   
                    builder.token_endpoint = Some(deser.read_string(member)?);
  238    238   
                }
  239    239   
                Some(4) => {
  240    240   
                    builder.user_info_endpoint = Some(deser.read_string(member)?);
  241    241   
                }
  242    242   
                Some(5) => {
  243    243   
                    builder.client_id = Some(deser.read_string(member)?);
  244    244   
                }
  245    245   
                Some(6) => {
  246    246   
                    builder.client_secret = Some(deser.read_string(member)?);
  247    247   
                }
  248    248   
                Some(7) => {
  249    249   
                    builder.scope = Some(deser.read_string(member)?);
  250    250   
                }
  251    251   
                _ => {}
  252    252   
            }
  253    253   
            Ok(())
  254    254   
        })?;
  255    255   
        Ok(builder.build())
  256    256   
    }
  257    257   
}
         258  +
impl CreateVerifiedAccessNativeApplicationOidcOptions {
         259  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         260  +
    pub fn deserialize_with_response(
         261  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         262  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         263  +
        _status: u16,
         264  +
        _body: &[u8],
         265  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         266  +
        Self::deserialize(deserializer)
         267  +
    }
         268  +
}
  258    269   
impl CreateVerifiedAccessNativeApplicationOidcOptions {
  259    270   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessNativeApplicationOidcOptions`](crate::types::CreateVerifiedAccessNativeApplicationOidcOptions).
  260    271   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessNativeApplicationOidcOptionsBuilder {
  261    272   
        crate::types::builders::CreateVerifiedAccessNativeApplicationOidcOptionsBuilder::default()
  262    273   
    }
  263    274   
}
  264    275   
  265    276   
/// A builder for [`CreateVerifiedAccessNativeApplicationOidcOptions`](crate::types::CreateVerifiedAccessNativeApplicationOidcOptions).
  266    277   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  267    278   
#[non_exhaustive]

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

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

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

@@ -47,47 +261,272 @@
   67     67   
    "com.amazonaws.ec2",
   68     68   
    "CreateVerifiedAccessTrustProviderOidcOptions",
   69     69   
);
   70     70   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_ISSUER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$Issuer",
   73     73   
        "com.amazonaws.ec2",
   74     74   
        "CreateVerifiedAccessTrustProviderOidcOptions",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "issuer",
          77  +
    "Issuer",
   78     78   
    0,
   79     79   
);
   80     80   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT: ::aws_smithy_schema::Schema =
   81     81   
    ::aws_smithy_schema::Schema::new_member(
   82     82   
        ::aws_smithy_schema::ShapeId::from_static(
   83     83   
            "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$AuthorizationEndpoint",
   84     84   
            "com.amazonaws.ec2",
   85     85   
            "CreateVerifiedAccessTrustProviderOidcOptions",
   86     86   
        ),
   87     87   
        ::aws_smithy_schema::ShapeType::String,
   88         -
        "authorization_endpoint",
          88  +
        "AuthorizationEndpoint",
   89     89   
        1,
   90     90   
    );
   91     91   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_TOKEN_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$TokenEndpoint",
   94     94   
        "com.amazonaws.ec2",
   95     95   
        "CreateVerifiedAccessTrustProviderOidcOptions",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::String,
   98         -
    "token_endpoint",
          98  +
    "TokenEndpoint",
   99     99   
    2,
  100    100   
);
  101    101   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$UserInfoEndpoint",
  104    104   
        "com.amazonaws.ec2",
  105    105   
        "CreateVerifiedAccessTrustProviderOidcOptions",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "user_info_endpoint",
         108  +
    "UserInfoEndpoint",
  109    109   
    3,
  110    110   
);
  111    111   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  112    112   
    ::aws_smithy_schema::ShapeId::from_static(
  113    113   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$ClientId",
  114    114   
        "com.amazonaws.ec2",
  115    115   
        "CreateVerifiedAccessTrustProviderOidcOptions",
  116    116   
    ),
  117    117   
    ::aws_smithy_schema::ShapeType::String,
  118         -
    "client_id",
         118  +
    "ClientId",
  119    119   
    4,
  120    120   
);
  121    121   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_SECRET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  122    122   
    ::aws_smithy_schema::ShapeId::from_static(
  123    123   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$ClientSecret",
  124    124   
        "com.amazonaws.ec2",
  125    125   
        "CreateVerifiedAccessTrustProviderOidcOptions",
  126    126   
    ),
  127    127   
    ::aws_smithy_schema::ShapeType::String,
  128         -
    "client_secret",
         128  +
    "ClientSecret",
  129    129   
    5,
  130    130   
);
  131    131   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_SCOPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  132    132   
    ::aws_smithy_schema::ShapeId::from_static(
  133    133   
        "com.amazonaws.ec2#CreateVerifiedAccessTrustProviderOidcOptions$Scope",
  134    134   
        "com.amazonaws.ec2",
  135    135   
        "CreateVerifiedAccessTrustProviderOidcOptions",
  136    136   
    ),
  137    137   
    ::aws_smithy_schema::ShapeType::String,
  138         -
    "scope",
         138  +
    "Scope",
  139    139   
    6,
  140    140   
);
  141    141   
static CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  142    142   
    CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_SCHEMA_ID,
  143    143   
    ::aws_smithy_schema::ShapeType::Structure,
  144    144   
    &[
  145    145   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_ISSUER,
  146    146   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT,
  147    147   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_TOKEN_ENDPOINT,
  148    148   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT,
  149    149   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_ID,
  150    150   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_SECRET,
  151    151   
        &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_SCOPE,
  152    152   
    ],
  153    153   
);
  154    154   
impl CreateVerifiedAccessTrustProviderOidcOptions {
  155    155   
    /// The schema for this shape.
  156    156   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_SCHEMA;
  157    157   
}
  158    158   
impl ::aws_smithy_schema::serde::SerializableStruct for CreateVerifiedAccessTrustProviderOidcOptions {
  159    159   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  160    160   
    fn serialize_members(
  161    161   
        &self,
  162    162   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  163    163   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  164    164   
        if let Some(ref val) = self.issuer {
  165    165   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_ISSUER, val)?;
  166    166   
        }
  167    167   
        if let Some(ref val) = self.authorization_endpoint {
  168    168   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_AUTHORIZATION_ENDPOINT, val)?;
  169    169   
        }
  170    170   
        if let Some(ref val) = self.token_endpoint {
  171    171   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_TOKEN_ENDPOINT, val)?;
  172    172   
        }
  173    173   
        if let Some(ref val) = self.user_info_endpoint {
  174    174   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_USER_INFO_ENDPOINT, val)?;
  175    175   
        }
  176    176   
        if let Some(ref val) = self.client_id {
  177    177   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_ID, val)?;
  178    178   
        }
  179    179   
        if let Some(ref val) = self.client_secret {
  180    180   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_CLIENT_SECRET, val)?;
  181    181   
        }
  182    182   
        if let Some(ref val) = self.scope {
  183    183   
            ser.write_string(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_MEMBER_SCOPE, val)?;
  184    184   
        }
  185    185   
        Ok(())
  186    186   
    }
  187    187   
}
  188    188   
impl CreateVerifiedAccessTrustProviderOidcOptions {
  189    189   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  190         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  191         -
        deserializer: &mut D,
         190  +
    pub fn deserialize(
         191  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  192    192   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  193    193   
        #[allow(unused_variables, unused_mut)]
  194    194   
        let mut builder = Self::builder();
  195    195   
        #[allow(
  196    196   
            unused_variables,
  197    197   
            unreachable_code,
  198    198   
            clippy::single_match,
  199    199   
            clippy::match_single_binding,
  200    200   
            clippy::diverging_sub_expression
  201    201   
        )]
  202         -
        deserializer.read_struct(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_SCHEMA, (), |_, member, deser| {
         202  +
        deserializer.read_struct(&CREATEVERIFIEDACCESSTRUSTPROVIDEROIDCOPTIONS_SCHEMA, &mut |member, deser| {
  203    203   
            match member.member_index() {
  204    204   
                Some(0) => {
  205    205   
                    builder.issuer = Some(deser.read_string(member)?);
  206    206   
                }
  207    207   
                Some(1) => {
  208    208   
                    builder.authorization_endpoint = Some(deser.read_string(member)?);
  209    209   
                }
  210    210   
                Some(2) => {
  211    211   
                    builder.token_endpoint = Some(deser.read_string(member)?);
  212    212   
                }
  213    213   
                Some(3) => {
  214    214   
                    builder.user_info_endpoint = Some(deser.read_string(member)?);
  215    215   
                }
  216    216   
                Some(4) => {
  217    217   
                    builder.client_id = Some(deser.read_string(member)?);
  218    218   
                }
  219    219   
                Some(5) => {
  220    220   
                    builder.client_secret = Some(deser.read_string(member)?);
  221    221   
                }
  222    222   
                Some(6) => {
  223    223   
                    builder.scope = Some(deser.read_string(member)?);
  224    224   
                }
  225    225   
                _ => {}
  226    226   
            }
  227    227   
            Ok(())
  228    228   
        })?;
  229    229   
        Ok(builder.build())
  230    230   
    }
  231    231   
}
         232  +
impl CreateVerifiedAccessTrustProviderOidcOptions {
         233  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         234  +
    pub fn deserialize_with_response(
         235  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         236  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         237  +
        _status: u16,
         238  +
        _body: &[u8],
         239  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         240  +
        Self::deserialize(deserializer)
         241  +
    }
         242  +
}
  232    243   
impl CreateVerifiedAccessTrustProviderOidcOptions {
  233    244   
    /// Creates a new builder-style object to manufacture [`CreateVerifiedAccessTrustProviderOidcOptions`](crate::types::CreateVerifiedAccessTrustProviderOidcOptions).
  234    245   
    pub fn builder() -> crate::types::builders::CreateVerifiedAccessTrustProviderOidcOptionsBuilder {
  235    246   
        crate::types::builders::CreateVerifiedAccessTrustProviderOidcOptionsBuilder::default()
  236    247   
    }
  237    248   
}
  238    249   
  239    250   
/// A builder for [`CreateVerifiedAccessTrustProviderOidcOptions`](crate::types::CreateVerifiedAccessTrustProviderOidcOptions).
  240    251   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
  241    252   
#[non_exhaustive]

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

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