AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_cidr_collection_change.rs

@@ -12,12 +181,184 @@
   32     32   
    "com.amazonaws.route53",
   33     33   
    "CidrCollectionChange",
   34     34   
);
   35     35   
static CIDRCOLLECTIONCHANGE_MEMBER_LOCATION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   36     36   
    ::aws_smithy_schema::ShapeId::from_static(
   37     37   
        "com.amazonaws.route53#CidrCollectionChange$LocationName",
   38     38   
        "com.amazonaws.route53",
   39     39   
        "CidrCollectionChange",
   40     40   
    ),
   41     41   
    ::aws_smithy_schema::ShapeType::String,
   42         -
    "location_name",
          42  +
    "LocationName",
   43     43   
    0,
   44     44   
);
   45     45   
static CIDRCOLLECTIONCHANGE_MEMBER_ACTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   46     46   
    ::aws_smithy_schema::ShapeId::from_static(
   47     47   
        "com.amazonaws.route53#CidrCollectionChange$Action",
   48     48   
        "com.amazonaws.route53",
   49     49   
        "CidrCollectionChange",
   50     50   
    ),
   51     51   
    ::aws_smithy_schema::ShapeType::String,
   52         -
    "action",
          52  +
    "Action",
   53     53   
    1,
   54     54   
);
   55     55   
static CIDRCOLLECTIONCHANGE_MEMBER_CIDR_LIST: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   56     56   
    ::aws_smithy_schema::ShapeId::from_static(
   57     57   
        "com.amazonaws.route53#CidrCollectionChange$CidrList",
   58     58   
        "com.amazonaws.route53",
   59     59   
        "CidrCollectionChange",
   60     60   
    ),
   61     61   
    ::aws_smithy_schema::ShapeType::List,
   62         -
    "cidr_list",
          62  +
    "CidrList",
   63     63   
    2,
   64     64   
);
   65     65   
static CIDRCOLLECTIONCHANGE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   66     66   
    CIDRCOLLECTIONCHANGE_SCHEMA_ID,
   67     67   
    ::aws_smithy_schema::ShapeType::Structure,
   68     68   
    &[
   69     69   
        &CIDRCOLLECTIONCHANGE_MEMBER_LOCATION_NAME,
   70     70   
        &CIDRCOLLECTIONCHANGE_MEMBER_ACTION,
   71     71   
        &CIDRCOLLECTIONCHANGE_MEMBER_CIDR_LIST,
   72     72   
    ],
   73     73   
);
   74     74   
impl CidrCollectionChange {
   75     75   
    /// The schema for this shape.
   76     76   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &CIDRCOLLECTIONCHANGE_SCHEMA;
   77     77   
}
   78     78   
impl ::aws_smithy_schema::serde::SerializableStruct for CidrCollectionChange {
   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   
        {
   85     85   
            let val = &self.location_name;
   86     86   
            ser.write_string(&CIDRCOLLECTIONCHANGE_MEMBER_LOCATION_NAME, val)?;
   87     87   
        }
   88     88   
        {
   89     89   
            let val = &self.action;
   90     90   
            ser.write_string(&CIDRCOLLECTIONCHANGE_MEMBER_ACTION, val.as_str())?;
   91     91   
        }
   92     92   
        {
   93     93   
            let val = &self.cidr_list;
   94     94   
   95     95   
            ser.write_list(
   96     96   
                &CIDRCOLLECTIONCHANGE_MEMBER_CIDR_LIST,
   97     97   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   98     98   
                    for item in val {
   99     99   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  100    100   
                    }
  101    101   
                    Ok(())
  102    102   
                },
  103    103   
            )?;
  104    104   
        }
  105    105   
        Ok(())
  106    106   
    }
  107    107   
}
  108    108   
impl CidrCollectionChange {
  109    109   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  110         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  111         -
        deserializer: &mut D,
         110  +
    pub fn deserialize(
         111  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  112    112   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  113    113   
        #[allow(unused_variables, unused_mut)]
  114    114   
        let mut builder = Self::builder();
  115    115   
        #[allow(
  116    116   
            unused_variables,
  117    117   
            unreachable_code,
  118    118   
            clippy::single_match,
  119    119   
            clippy::match_single_binding,
  120    120   
            clippy::diverging_sub_expression
  121    121   
        )]
  122         -
        deserializer.read_struct(&CIDRCOLLECTIONCHANGE_SCHEMA, (), |_, member, deser| {
         122  +
        deserializer.read_struct(&CIDRCOLLECTIONCHANGE_SCHEMA, &mut |member, deser| {
  123    123   
            match member.member_index() {
  124    124   
                Some(0) => {
  125    125   
                    builder.location_name = Some(deser.read_string(member)?);
  126    126   
                }
  127    127   
                Some(1) => {
  128    128   
                    builder.action = Some(crate::types::CidrCollectionChangeAction::from(deser.read_string(member)?.as_str()));
  129    129   
                }
  130    130   
                Some(2) => {
  131         -
                    builder.cidr_list = Some({
  132         -
                        let container = if let Some(cap) = deser.container_size() {
  133         -
                            Vec::with_capacity(cap)
  134         -
                        } else {
  135         -
                            Vec::new()
  136         -
                        };
  137         -
                        deser.read_list(member, container, |mut list, deser| {
  138         -
                            list.push(deser.read_string(member)?);
  139         -
                            Ok(list)
  140         -
                        })?
  141         -
                    });
         131  +
                    builder.cidr_list = Some(deser.read_string_list(member)?);
  142    132   
                }
  143    133   
                _ => {}
  144    134   
            }
  145    135   
            Ok(())
  146    136   
        })?;
         137  +
        builder.location_name = builder.location_name.or(Some(String::new()));
         138  +
        builder.cidr_list = builder.cidr_list.or(Some(Vec::new()));
  147    139   
        builder
  148    140   
            .build()
  149    141   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  150    142   
    }
  151    143   
}
         144  +
impl CidrCollectionChange {
         145  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         146  +
    pub fn deserialize_with_response(
         147  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         148  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         149  +
        _status: u16,
         150  +
        _body: &[u8],
         151  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         152  +
        Self::deserialize(deserializer)
         153  +
    }
         154  +
}
  152    155   
impl CidrCollectionChange {
  153    156   
    /// Creates a new builder-style object to manufacture [`CidrCollectionChange`](crate::types::CidrCollectionChange).
  154    157   
    pub fn builder() -> crate::types::builders::CidrCollectionChangeBuilder {
  155    158   
        crate::types::builders::CidrCollectionChangeBuilder::default()
  156    159   
    }
  157    160   
}
  158    161   
  159    162   
/// A builder for [`CidrCollectionChange`](crate::types::CidrCollectionChange).
  160    163   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  161    164   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_cidr_routing_config.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_cloud_watch_alarm_configuration.rs

@@ -44,44 +174,174 @@
   64     64   
    "com.amazonaws.route53",
   65     65   
    "CloudWatchAlarmConfiguration",
   66     66   
);
   67     67   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_EVALUATION_PERIODS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$EvaluationPeriods",
   70     70   
        "com.amazonaws.route53",
   71     71   
        "CloudWatchAlarmConfiguration",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::Integer,
   74         -
    "evaluation_periods",
          74  +
    "EvaluationPeriods",
   75     75   
    0,
   76     76   
);
   77     77   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$Threshold",
   80     80   
        "com.amazonaws.route53",
   81     81   
        "CloudWatchAlarmConfiguration",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Double,
   84         -
    "threshold",
          84  +
    "Threshold",
   85     85   
    1,
   86     86   
);
   87     87   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_COMPARISON_OPERATOR: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$ComparisonOperator",
   90     90   
        "com.amazonaws.route53",
   91     91   
        "CloudWatchAlarmConfiguration",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::String,
   94         -
    "comparison_operator",
          94  +
    "ComparisonOperator",
   95     95   
    2,
   96     96   
);
   97     97   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_PERIOD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   98     98   
    ::aws_smithy_schema::ShapeId::from_static(
   99     99   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$Period",
  100    100   
        "com.amazonaws.route53",
  101    101   
        "CloudWatchAlarmConfiguration",
  102    102   
    ),
  103    103   
    ::aws_smithy_schema::ShapeType::Integer,
  104         -
    "period",
         104  +
    "Period",
  105    105   
    3,
  106    106   
);
  107    107   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_METRIC_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  108    108   
    ::aws_smithy_schema::ShapeId::from_static(
  109    109   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$MetricName",
  110    110   
        "com.amazonaws.route53",
  111    111   
        "CloudWatchAlarmConfiguration",
  112    112   
    ),
  113    113   
    ::aws_smithy_schema::ShapeType::String,
  114         -
    "metric_name",
         114  +
    "MetricName",
  115    115   
    4,
  116    116   
);
  117    117   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_NAMESPACE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  118    118   
    ::aws_smithy_schema::ShapeId::from_static(
  119    119   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$Namespace",
  120    120   
        "com.amazonaws.route53",
  121    121   
        "CloudWatchAlarmConfiguration",
  122    122   
    ),
  123    123   
    ::aws_smithy_schema::ShapeType::String,
  124         -
    "namespace",
         124  +
    "Namespace",
  125    125   
    5,
  126    126   
);
  127    127   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_STATISTIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  128    128   
    ::aws_smithy_schema::ShapeId::from_static(
  129    129   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$Statistic",
  130    130   
        "com.amazonaws.route53",
  131    131   
        "CloudWatchAlarmConfiguration",
  132    132   
    ),
  133    133   
    ::aws_smithy_schema::ShapeType::String,
  134         -
    "statistic",
         134  +
    "Statistic",
  135    135   
    6,
  136    136   
);
  137    137   
static CLOUDWATCHALARMCONFIGURATION_MEMBER_DIMENSIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  138    138   
    ::aws_smithy_schema::ShapeId::from_static(
  139    139   
        "com.amazonaws.route53#CloudWatchAlarmConfiguration$Dimensions",
  140    140   
        "com.amazonaws.route53",
  141    141   
        "CloudWatchAlarmConfiguration",
  142    142   
    ),
  143    143   
    ::aws_smithy_schema::ShapeType::List,
  144         -
    "dimensions",
         144  +
    "Dimensions",
  145    145   
    7,
  146    146   
);
  147    147   
static CLOUDWATCHALARMCONFIGURATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  148    148   
    CLOUDWATCHALARMCONFIGURATION_SCHEMA_ID,
  149    149   
    ::aws_smithy_schema::ShapeType::Structure,
  150    150   
    &[
  151    151   
        &CLOUDWATCHALARMCONFIGURATION_MEMBER_EVALUATION_PERIODS,
  152    152   
        &CLOUDWATCHALARMCONFIGURATION_MEMBER_THRESHOLD,
  153    153   
        &CLOUDWATCHALARMCONFIGURATION_MEMBER_COMPARISON_OPERATOR,
  154    154   
        &CLOUDWATCHALARMCONFIGURATION_MEMBER_PERIOD,
@@ -185,185 +301,314 @@
  205    205   
                    }
  206    206   
                    Ok(())
  207    207   
                },
  208    208   
            )?;
  209    209   
        }
  210    210   
        Ok(())
  211    211   
    }
  212    212   
}
  213    213   
impl CloudWatchAlarmConfiguration {
  214    214   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  215         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  216         -
        deserializer: &mut D,
         215  +
    pub fn deserialize(
         216  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  217    217   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  218    218   
        #[allow(unused_variables, unused_mut)]
  219    219   
        let mut builder = Self::builder();
  220    220   
        #[allow(
  221    221   
            unused_variables,
  222    222   
            unreachable_code,
  223    223   
            clippy::single_match,
  224    224   
            clippy::match_single_binding,
  225    225   
            clippy::diverging_sub_expression
  226    226   
        )]
  227         -
        deserializer.read_struct(&CLOUDWATCHALARMCONFIGURATION_SCHEMA, (), |_, member, deser| {
         227  +
        deserializer.read_struct(&CLOUDWATCHALARMCONFIGURATION_SCHEMA, &mut |member, deser| {
  228    228   
            match member.member_index() {
  229    229   
                Some(0) => {
  230    230   
                    builder.evaluation_periods = Some(deser.read_integer(member)?);
  231    231   
                }
  232    232   
                Some(1) => {
  233    233   
                    builder.threshold = Some(deser.read_double(member)?);
  234    234   
                }
  235    235   
                Some(2) => {
  236    236   
                    builder.comparison_operator = Some(crate::types::ComparisonOperator::from(deser.read_string(member)?.as_str()));
  237    237   
                }
  238    238   
                Some(3) => {
  239    239   
                    builder.period = Some(deser.read_integer(member)?);
  240    240   
                }
  241    241   
                Some(4) => {
  242    242   
                    builder.metric_name = Some(deser.read_string(member)?);
  243    243   
                }
  244    244   
                Some(5) => {
  245    245   
                    builder.namespace = Some(deser.read_string(member)?);
  246    246   
                }
  247    247   
                Some(6) => {
  248    248   
                    builder.statistic = Some(crate::types::Statistic::from(deser.read_string(member)?.as_str()));
  249    249   
                }
  250    250   
                Some(7) => {
  251    251   
                    builder.dimensions = Some({
  252         -
                        let container = if let Some(cap) = deser.container_size() {
  253         -
                            Vec::with_capacity(cap)
  254         -
                        } else {
  255         -
                            Vec::new()
  256         -
                        };
  257         -
                        deser.read_list(member, container, |mut list, deser| {
  258         -
                            list.push(crate::types::Dimension::deserialize(deser)?);
  259         -
                            Ok(list)
  260         -
                        })?
         252  +
                        let mut container = Vec::new();
         253  +
                        deser.read_list(member, &mut |deser| {
         254  +
                            container.push(crate::types::Dimension::deserialize(deser)?);
         255  +
                            Ok(())
         256  +
                        })?;
         257  +
                        container
  261    258   
                    });
  262    259   
                }
  263    260   
                _ => {}
  264    261   
            }
  265    262   
            Ok(())
  266    263   
        })?;
         264  +
        builder.evaluation_periods = builder.evaluation_periods.or(Some(0i32));
         265  +
        builder.threshold = builder.threshold.or(Some(0.0f64));
         266  +
        builder.period = builder.period.or(Some(0i32));
         267  +
        builder.metric_name = builder.metric_name.or(Some(String::new()));
         268  +
        builder.namespace = builder.namespace.or(Some(String::new()));
  267    269   
        builder
  268    270   
            .build()
  269    271   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  270    272   
    }
  271    273   
}
         274  +
impl CloudWatchAlarmConfiguration {
         275  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         276  +
    pub fn deserialize_with_response(
         277  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         278  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         279  +
        _status: u16,
         280  +
        _body: &[u8],
         281  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         282  +
        Self::deserialize(deserializer)
         283  +
    }
         284  +
}
  272    285   
impl CloudWatchAlarmConfiguration {
  273    286   
    /// Creates a new builder-style object to manufacture [`CloudWatchAlarmConfiguration`](crate::types::CloudWatchAlarmConfiguration).
  274    287   
    pub fn builder() -> crate::types::builders::CloudWatchAlarmConfigurationBuilder {
  275    288   
        crate::types::builders::CloudWatchAlarmConfigurationBuilder::default()
  276    289   
    }
  277    290   
}
  278    291   
  279    292   
/// A builder for [`CloudWatchAlarmConfiguration`](crate::types::CloudWatchAlarmConfiguration).
  280    293   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  281    294   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_collection_summary.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_coordinates.rs

@@ -1,1 +124,137 @@
   19     19   
    pub fn longitude(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.longitude.deref()
   22     22   
    }
   23     23   
}
   24     24   
static COORDINATES_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Coordinates", "com.amazonaws.route53", "Coordinates");
   26     26   
static COORDINATES_MEMBER_LATITUDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Coordinates$Latitude", "com.amazonaws.route53", "Coordinates"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "latitude",
          29  +
    "Latitude",
   30     30   
    0,
   31     31   
);
   32     32   
static COORDINATES_MEMBER_LONGITUDE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Coordinates$Longitude", "com.amazonaws.route53", "Coordinates"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "longitude",
          35  +
    "Longitude",
   36     36   
    1,
   37     37   
);
   38     38   
static COORDINATES_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    COORDINATES_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&COORDINATES_MEMBER_LATITUDE, &COORDINATES_MEMBER_LONGITUDE],
   42     42   
);
   43     43   
impl Coordinates {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &COORDINATES_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for Coordinates {
   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   
        {
   54     54   
            let val = &self.latitude;
   55     55   
            ser.write_string(&COORDINATES_MEMBER_LATITUDE, val)?;
   56     56   
        }
   57     57   
        {
   58     58   
            let val = &self.longitude;
   59     59   
            ser.write_string(&COORDINATES_MEMBER_LONGITUDE, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl Coordinates {
   65     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        #[allow(unused_variables, unused_mut)]
   70     70   
        let mut builder = Self::builder();
   71     71   
        #[allow(
   72     72   
            unused_variables,
   73     73   
            unreachable_code,
   74     74   
            clippy::single_match,
   75     75   
            clippy::match_single_binding,
   76     76   
            clippy::diverging_sub_expression
   77     77   
        )]
   78         -
        deserializer.read_struct(&COORDINATES_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&COORDINATES_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.latitude = Some(deser.read_string(member)?);
   82     82   
                }
   83     83   
                Some(1) => {
   84     84   
                    builder.longitude = Some(deser.read_string(member)?);
   85     85   
                }
   86     86   
                _ => {}
   87     87   
            }
   88     88   
            Ok(())
   89     89   
        })?;
          90  +
        builder.latitude = builder.latitude.or(Some(String::new()));
          91  +
        builder.longitude = builder.longitude.or(Some(String::new()));
   90     92   
        builder
   91     93   
            .build()
   92     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   93     95   
    }
   94     96   
}
          97  +
impl Coordinates {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   95    108   
impl Coordinates {
   96    109   
    /// Creates a new builder-style object to manufacture [`Coordinates`](crate::types::Coordinates).
   97    110   
    pub fn builder() -> crate::types::builders::CoordinatesBuilder {
   98    111   
        crate::types::builders::CoordinatesBuilder::default()
   99    112   
    }
  100    113   
}
  101    114   
  102    115   
/// A builder for [`Coordinates`](crate::types::Coordinates).
  103    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  104    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_delegation_set.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_dimension.rs

@@ -1,1 +124,137 @@
   19     19   
    pub fn value(&self) -> &str {
   20     20   
        use std::ops::Deref;
   21     21   
        self.value.deref()
   22     22   
    }
   23     23   
}
   24     24   
static DIMENSION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Dimension", "com.amazonaws.route53", "Dimension");
   26     26   
static DIMENSION_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   27     27   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Dimension$Name", "com.amazonaws.route53", "Dimension"),
   28     28   
    ::aws_smithy_schema::ShapeType::String,
   29         -
    "name",
          29  +
    "Name",
   30     30   
    0,
   31     31   
);
   32     32   
static DIMENSION_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   33     33   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#Dimension$Value", "com.amazonaws.route53", "Dimension"),
   34     34   
    ::aws_smithy_schema::ShapeType::String,
   35         -
    "value",
          35  +
    "Value",
   36     36   
    1,
   37     37   
);
   38     38   
static DIMENSION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   39     39   
    DIMENSION_SCHEMA_ID,
   40     40   
    ::aws_smithy_schema::ShapeType::Structure,
   41     41   
    &[&DIMENSION_MEMBER_NAME, &DIMENSION_MEMBER_VALUE],
   42     42   
);
   43     43   
impl Dimension {
   44     44   
    /// The schema for this shape.
   45     45   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DIMENSION_SCHEMA;
   46     46   
}
   47     47   
impl ::aws_smithy_schema::serde::SerializableStruct for Dimension {
   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   
        {
   54     54   
            let val = &self.name;
   55     55   
            ser.write_string(&DIMENSION_MEMBER_NAME, val)?;
   56     56   
        }
   57     57   
        {
   58     58   
            let val = &self.value;
   59     59   
            ser.write_string(&DIMENSION_MEMBER_VALUE, val)?;
   60     60   
        }
   61     61   
        Ok(())
   62     62   
    }
   63     63   
}
   64     64   
impl Dimension {
   65     65   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   66         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   67         -
        deserializer: &mut D,
          66  +
    pub fn deserialize(
          67  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   68     68   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   69     69   
        #[allow(unused_variables, unused_mut)]
   70     70   
        let mut builder = Self::builder();
   71     71   
        #[allow(
   72     72   
            unused_variables,
   73     73   
            unreachable_code,
   74     74   
            clippy::single_match,
   75     75   
            clippy::match_single_binding,
   76     76   
            clippy::diverging_sub_expression
   77     77   
        )]
   78         -
        deserializer.read_struct(&DIMENSION_SCHEMA, (), |_, member, deser| {
          78  +
        deserializer.read_struct(&DIMENSION_SCHEMA, &mut |member, deser| {
   79     79   
            match member.member_index() {
   80     80   
                Some(0) => {
   81     81   
                    builder.name = Some(deser.read_string(member)?);
   82     82   
                }
   83     83   
                Some(1) => {
   84     84   
                    builder.value = Some(deser.read_string(member)?);
   85     85   
                }
   86     86   
                _ => {}
   87     87   
            }
   88     88   
            Ok(())
   89     89   
        })?;
          90  +
        builder.name = builder.name.or(Some(String::new()));
          91  +
        builder.value = builder.value.or(Some(String::new()));
   90     92   
        builder
   91     93   
            .build()
   92     94   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
   93     95   
    }
   94     96   
}
          97  +
impl Dimension {
          98  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        Self::deserialize(deserializer)
         106  +
    }
         107  +
}
   95    108   
impl Dimension {
   96    109   
    /// Creates a new builder-style object to manufacture [`Dimension`](crate::types::Dimension).
   97    110   
    pub fn builder() -> crate::types::builders::DimensionBuilder {
   98    111   
        crate::types::builders::DimensionBuilder::default()
   99    112   
    }
  100    113   
}
  101    114   
  102    115   
/// A builder for [`Dimension`](crate::types::Dimension).
  103    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  104    117   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_dnssec_status.rs

@@ -67,67 +192,203 @@
   87     87   
}
   88     88   
static DNSSECSTATUS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   89     89   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#DNSSECStatus", "com.amazonaws.route53", "DNSSECStatus");
   90     90   
static DNSSECSTATUS_MEMBER_SERVE_SIGNATURE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.route53#DNSSECStatus$ServeSignature",
   93     93   
        "com.amazonaws.route53",
   94     94   
        "DNSSECStatus",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::String,
   97         -
    "serve_signature",
          97  +
    "ServeSignature",
   98     98   
    0,
   99     99   
);
  100    100   
static DNSSECSTATUS_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  101    101   
    ::aws_smithy_schema::ShapeId::from_static(
  102    102   
        "com.amazonaws.route53#DNSSECStatus$StatusMessage",
  103    103   
        "com.amazonaws.route53",
  104    104   
        "DNSSECStatus",
  105    105   
    ),
  106    106   
    ::aws_smithy_schema::ShapeType::String,
  107         -
    "status_message",
         107  +
    "StatusMessage",
  108    108   
    1,
  109    109   
);
  110    110   
static DNSSECSTATUS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  111    111   
    DNSSECSTATUS_SCHEMA_ID,
  112    112   
    ::aws_smithy_schema::ShapeType::Structure,
  113    113   
    &[&DNSSECSTATUS_MEMBER_SERVE_SIGNATURE, &DNSSECSTATUS_MEMBER_STATUS_MESSAGE],
  114    114   
);
  115    115   
impl DnssecStatus {
  116    116   
    /// The schema for this shape.
  117    117   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &DNSSECSTATUS_SCHEMA;
  118    118   
}
  119    119   
impl ::aws_smithy_schema::serde::SerializableStruct for DnssecStatus {
  120    120   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  121    121   
    fn serialize_members(
  122    122   
        &self,
  123    123   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  124    124   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  125    125   
        if let Some(ref val) = self.serve_signature {
  126    126   
            ser.write_string(&DNSSECSTATUS_MEMBER_SERVE_SIGNATURE, val)?;
  127    127   
        }
  128    128   
        if let Some(ref val) = self.status_message {
  129    129   
            ser.write_string(&DNSSECSTATUS_MEMBER_STATUS_MESSAGE, val)?;
  130    130   
        }
  131    131   
        Ok(())
  132    132   
    }
  133    133   
}
  134    134   
impl DnssecStatus {
  135    135   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  136         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  137         -
        deserializer: &mut D,
         136  +
    pub fn deserialize(
         137  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  138    138   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  139    139   
        #[allow(unused_variables, unused_mut)]
  140    140   
        let mut builder = Self::builder();
  141    141   
        #[allow(
  142    142   
            unused_variables,
  143    143   
            unreachable_code,
  144    144   
            clippy::single_match,
  145    145   
            clippy::match_single_binding,
  146    146   
            clippy::diverging_sub_expression
  147    147   
        )]
  148         -
        deserializer.read_struct(&DNSSECSTATUS_SCHEMA, (), |_, member, deser| {
         148  +
        deserializer.read_struct(&DNSSECSTATUS_SCHEMA, &mut |member, deser| {
  149    149   
            match member.member_index() {
  150    150   
                Some(0) => {
  151    151   
                    builder.serve_signature = Some(deser.read_string(member)?);
  152    152   
                }
  153    153   
                Some(1) => {
  154    154   
                    builder.status_message = Some(deser.read_string(member)?);
  155    155   
                }
  156    156   
                _ => {}
  157    157   
            }
  158    158   
            Ok(())
  159    159   
        })?;
  160    160   
        Ok(builder.build())
  161    161   
    }
  162    162   
}
         163  +
impl DnssecStatus {
         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 DnssecStatus {
  164    175   
    /// Creates a new builder-style object to manufacture [`DnssecStatus`](crate::types::DnssecStatus).
  165    176   
    pub fn builder() -> crate::types::builders::DnssecStatusBuilder {
  166    177   
        crate::types::builders::DnssecStatusBuilder::default()
  167    178   
    }
  168    179   
}
  169    180   
  170    181   
/// A builder for [`DnssecStatus`](crate::types::DnssecStatus).
  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/route53/src/types/_geo_location.rs

@@ -45,45 +186,197 @@
   65     65   
    /// <p>If you specify <code>subdivisioncode</code>, you must also specify <code>US</code> for <code>CountryCode</code>.</p>
   66     66   
    pub fn subdivision_code(&self) -> ::std::option::Option<&str> {
   67     67   
        self.subdivision_code.as_deref()
   68     68   
    }
   69     69   
}
   70     70   
static GEOLOCATION_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   71     71   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#GeoLocation", "com.amazonaws.route53", "GeoLocation");
   72     72   
static GEOLOCATION_MEMBER_CONTINENT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#GeoLocation$ContinentCode", "com.amazonaws.route53", "GeoLocation"),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "continent_code",
          75  +
    "ContinentCode",
   76     76   
    0,
   77     77   
);
   78     78   
static GEOLOCATION_MEMBER_COUNTRY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#GeoLocation$CountryCode", "com.amazonaws.route53", "GeoLocation"),
   80     80   
    ::aws_smithy_schema::ShapeType::String,
   81         -
    "country_code",
          81  +
    "CountryCode",
   82     82   
    1,
   83     83   
);
   84     84   
static GEOLOCATION_MEMBER_SUBDIVISION_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   85     85   
    ::aws_smithy_schema::ShapeId::from_static(
   86     86   
        "com.amazonaws.route53#GeoLocation$SubdivisionCode",
   87     87   
        "com.amazonaws.route53",
   88     88   
        "GeoLocation",
   89     89   
    ),
   90     90   
    ::aws_smithy_schema::ShapeType::String,
   91         -
    "subdivision_code",
          91  +
    "SubdivisionCode",
   92     92   
    2,
   93     93   
);
   94     94   
static GEOLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   95     95   
    GEOLOCATION_SCHEMA_ID,
   96     96   
    ::aws_smithy_schema::ShapeType::Structure,
   97     97   
    &[
   98     98   
        &GEOLOCATION_MEMBER_CONTINENT_CODE,
   99     99   
        &GEOLOCATION_MEMBER_COUNTRY_CODE,
  100    100   
        &GEOLOCATION_MEMBER_SUBDIVISION_CODE,
  101    101   
    ],
  102    102   
);
  103    103   
impl GeoLocation {
  104    104   
    /// The schema for this shape.
  105    105   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GEOLOCATION_SCHEMA;
  106    106   
}
  107    107   
impl ::aws_smithy_schema::serde::SerializableStruct for GeoLocation {
  108    108   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  109    109   
    fn serialize_members(
  110    110   
        &self,
  111    111   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  112    112   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  113    113   
        if let Some(ref val) = self.continent_code {
  114    114   
            ser.write_string(&GEOLOCATION_MEMBER_CONTINENT_CODE, val)?;
  115    115   
        }
  116    116   
        if let Some(ref val) = self.country_code {
  117    117   
            ser.write_string(&GEOLOCATION_MEMBER_COUNTRY_CODE, val)?;
  118    118   
        }
  119    119   
        if let Some(ref val) = self.subdivision_code {
  120    120   
            ser.write_string(&GEOLOCATION_MEMBER_SUBDIVISION_CODE, val)?;
  121    121   
        }
  122    122   
        Ok(())
  123    123   
    }
  124    124   
}
  125    125   
impl GeoLocation {
  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(&GEOLOCATION_SCHEMA, (), |_, member, deser| {
         139  +
        deserializer.read_struct(&GEOLOCATION_SCHEMA, &mut |member, deser| {
  140    140   
            match member.member_index() {
  141    141   
                Some(0) => {
  142    142   
                    builder.continent_code = Some(deser.read_string(member)?);
  143    143   
                }
  144    144   
                Some(1) => {
  145    145   
                    builder.country_code = Some(deser.read_string(member)?);
  146    146   
                }
  147    147   
                Some(2) => {
  148    148   
                    builder.subdivision_code = Some(deser.read_string(member)?);
  149    149   
                }
  150    150   
                _ => {}
  151    151   
            }
  152    152   
            Ok(())
  153    153   
        })?;
  154    154   
        Ok(builder.build())
  155    155   
    }
  156    156   
}
         157  +
impl GeoLocation {
         158  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         159  +
    pub fn deserialize_with_response(
         160  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         161  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         162  +
        _status: u16,
         163  +
        _body: &[u8],
         164  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         165  +
        Self::deserialize(deserializer)
         166  +
    }
         167  +
}
  157    168   
impl GeoLocation {
  158    169   
    /// Creates a new builder-style object to manufacture [`GeoLocation`](crate::types::GeoLocation).
  159    170   
    pub fn builder() -> crate::types::builders::GeoLocationBuilder {
  160    171   
        crate::types::builders::GeoLocationBuilder::default()
  161    172   
    }
  162    173   
}
  163    174   
  164    175   
/// A builder for [`GeoLocation`](crate::types::GeoLocation).
  165    176   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  166    177   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_geo_location_details.rs

@@ -25,25 +221,232 @@
   45     45   
}
   46     46   
static GEOLOCATIONDETAILS_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   47     47   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#GeoLocationDetails", "com.amazonaws.route53", "GeoLocationDetails");
   48     48   
static GEOLOCATIONDETAILS_MEMBER_CONTINENT_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   49     49   
    ::aws_smithy_schema::ShapeId::from_static(
   50     50   
        "com.amazonaws.route53#GeoLocationDetails$ContinentCode",
   51     51   
        "com.amazonaws.route53",
   52     52   
        "GeoLocationDetails",
   53     53   
    ),
   54     54   
    ::aws_smithy_schema::ShapeType::String,
   55         -
    "continent_code",
          55  +
    "ContinentCode",
   56     56   
    0,
   57     57   
);
   58     58   
static GEOLOCATIONDETAILS_MEMBER_CONTINENT_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   59     59   
    ::aws_smithy_schema::ShapeId::from_static(
   60     60   
        "com.amazonaws.route53#GeoLocationDetails$ContinentName",
   61     61   
        "com.amazonaws.route53",
   62     62   
        "GeoLocationDetails",
   63     63   
    ),
   64     64   
    ::aws_smithy_schema::ShapeType::String,
   65         -
    "continent_name",
          65  +
    "ContinentName",
   66     66   
    1,
   67     67   
);
   68     68   
static GEOLOCATIONDETAILS_MEMBER_COUNTRY_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   69     69   
    ::aws_smithy_schema::ShapeId::from_static(
   70     70   
        "com.amazonaws.route53#GeoLocationDetails$CountryCode",
   71     71   
        "com.amazonaws.route53",
   72     72   
        "GeoLocationDetails",
   73     73   
    ),
   74     74   
    ::aws_smithy_schema::ShapeType::String,
   75         -
    "country_code",
          75  +
    "CountryCode",
   76     76   
    2,
   77     77   
);
   78     78   
static GEOLOCATIONDETAILS_MEMBER_COUNTRY_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   79     79   
    ::aws_smithy_schema::ShapeId::from_static(
   80     80   
        "com.amazonaws.route53#GeoLocationDetails$CountryName",
   81     81   
        "com.amazonaws.route53",
   82     82   
        "GeoLocationDetails",
   83     83   
    ),
   84     84   
    ::aws_smithy_schema::ShapeType::String,
   85         -
    "country_name",
          85  +
    "CountryName",
   86     86   
    3,
   87     87   
);
   88     88   
static GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_CODE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   89     89   
    ::aws_smithy_schema::ShapeId::from_static(
   90     90   
        "com.amazonaws.route53#GeoLocationDetails$SubdivisionCode",
   91     91   
        "com.amazonaws.route53",
   92     92   
        "GeoLocationDetails",
   93     93   
    ),
   94     94   
    ::aws_smithy_schema::ShapeType::String,
   95         -
    "subdivision_code",
          95  +
    "SubdivisionCode",
   96     96   
    4,
   97     97   
);
   98     98   
static GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.route53#GeoLocationDetails$SubdivisionName",
  101    101   
        "com.amazonaws.route53",
  102    102   
        "GeoLocationDetails",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::String,
  105         -
    "subdivision_name",
         105  +
    "SubdivisionName",
  106    106   
    5,
  107    107   
);
  108    108   
static GEOLOCATIONDETAILS_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  109    109   
    GEOLOCATIONDETAILS_SCHEMA_ID,
  110    110   
    ::aws_smithy_schema::ShapeType::Structure,
  111    111   
    &[
  112    112   
        &GEOLOCATIONDETAILS_MEMBER_CONTINENT_CODE,
  113    113   
        &GEOLOCATIONDETAILS_MEMBER_CONTINENT_NAME,
  114    114   
        &GEOLOCATIONDETAILS_MEMBER_COUNTRY_CODE,
  115    115   
        &GEOLOCATIONDETAILS_MEMBER_COUNTRY_NAME,
  116    116   
        &GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_CODE,
  117    117   
        &GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_NAME,
  118    118   
    ],
  119    119   
);
  120    120   
impl GeoLocationDetails {
  121    121   
    /// The schema for this shape.
  122    122   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GEOLOCATIONDETAILS_SCHEMA;
  123    123   
}
  124    124   
impl ::aws_smithy_schema::serde::SerializableStruct for GeoLocationDetails {
  125    125   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  126    126   
    fn serialize_members(
  127    127   
        &self,
  128    128   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  129    129   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  130    130   
        if let Some(ref val) = self.continent_code {
  131    131   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_CONTINENT_CODE, val)?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.continent_name {
  134    134   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_CONTINENT_NAME, val)?;
  135    135   
        }
  136    136   
        if let Some(ref val) = self.country_code {
  137    137   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_COUNTRY_CODE, val)?;
  138    138   
        }
  139    139   
        if let Some(ref val) = self.country_name {
  140    140   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_COUNTRY_NAME, val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.subdivision_code {
  143    143   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_CODE, val)?;
  144    144   
        }
  145    145   
        if let Some(ref val) = self.subdivision_name {
  146    146   
            ser.write_string(&GEOLOCATIONDETAILS_MEMBER_SUBDIVISION_NAME, val)?;
  147    147   
        }
  148    148   
        Ok(())
  149    149   
    }
  150    150   
}
  151    151   
impl GeoLocationDetails {
  152    152   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  153         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  154         -
        deserializer: &mut D,
         153  +
    pub fn deserialize(
         154  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  155    155   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  156    156   
        #[allow(unused_variables, unused_mut)]
  157    157   
        let mut builder = Self::builder();
  158    158   
        #[allow(
  159    159   
            unused_variables,
  160    160   
            unreachable_code,
  161    161   
            clippy::single_match,
  162    162   
            clippy::match_single_binding,
  163    163   
            clippy::diverging_sub_expression
  164    164   
        )]
  165         -
        deserializer.read_struct(&GEOLOCATIONDETAILS_SCHEMA, (), |_, member, deser| {
         165  +
        deserializer.read_struct(&GEOLOCATIONDETAILS_SCHEMA, &mut |member, deser| {
  166    166   
            match member.member_index() {
  167    167   
                Some(0) => {
  168    168   
                    builder.continent_code = Some(deser.read_string(member)?);
  169    169   
                }
  170    170   
                Some(1) => {
  171    171   
                    builder.continent_name = Some(deser.read_string(member)?);
  172    172   
                }
  173    173   
                Some(2) => {
  174    174   
                    builder.country_code = Some(deser.read_string(member)?);
  175    175   
                }
  176    176   
                Some(3) => {
  177    177   
                    builder.country_name = Some(deser.read_string(member)?);
  178    178   
                }
  179    179   
                Some(4) => {
  180    180   
                    builder.subdivision_code = Some(deser.read_string(member)?);
  181    181   
                }
  182    182   
                Some(5) => {
  183    183   
                    builder.subdivision_name = Some(deser.read_string(member)?);
  184    184   
                }
  185    185   
                _ => {}
  186    186   
            }
  187    187   
            Ok(())
  188    188   
        })?;
  189    189   
        Ok(builder.build())
  190    190   
    }
  191    191   
}
         192  +
impl GeoLocationDetails {
         193  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         194  +
    pub fn deserialize_with_response(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         196  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         197  +
        _status: u16,
         198  +
        _body: &[u8],
         199  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         200  +
        Self::deserialize(deserializer)
         201  +
    }
         202  +
}
  192    203   
impl GeoLocationDetails {
  193    204   
    /// Creates a new builder-style object to manufacture [`GeoLocationDetails`](crate::types::GeoLocationDetails).
  194    205   
    pub fn builder() -> crate::types::builders::GeoLocationDetailsBuilder {
  195    206   
        crate::types::builders::GeoLocationDetailsBuilder::default()
  196    207   
    }
  197    208   
}
  198    209   
  199    210   
/// A builder for [`GeoLocationDetails`](crate::types::GeoLocationDetails).
  200    211   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  201    212   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_geo_proximity_location.rs

@@ -37,37 +199,210 @@
   57     57   
    "com.amazonaws.route53",
   58     58   
    "GeoProximityLocation",
   59     59   
);
   60     60   
static GEOPROXIMITYLOCATION_MEMBER_AWS_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   61     61   
    ::aws_smithy_schema::ShapeId::from_static(
   62     62   
        "com.amazonaws.route53#GeoProximityLocation$AWSRegion",
   63     63   
        "com.amazonaws.route53",
   64     64   
        "GeoProximityLocation",
   65     65   
    ),
   66     66   
    ::aws_smithy_schema::ShapeType::String,
   67         -
    "aws_region",
          67  +
    "AWSRegion",
   68     68   
    0,
   69     69   
);
   70     70   
static GEOPROXIMITYLOCATION_MEMBER_LOCAL_ZONE_GROUP: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   71     71   
    ::aws_smithy_schema::ShapeId::from_static(
   72     72   
        "com.amazonaws.route53#GeoProximityLocation$LocalZoneGroup",
   73     73   
        "com.amazonaws.route53",
   74     74   
        "GeoProximityLocation",
   75     75   
    ),
   76     76   
    ::aws_smithy_schema::ShapeType::String,
   77         -
    "local_zone_group",
          77  +
    "LocalZoneGroup",
   78     78   
    1,
   79     79   
);
   80     80   
static GEOPROXIMITYLOCATION_MEMBER_COORDINATES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   81     81   
    ::aws_smithy_schema::ShapeId::from_static(
   82     82   
        "com.amazonaws.route53#GeoProximityLocation$Coordinates",
   83     83   
        "com.amazonaws.route53",
   84     84   
        "GeoProximityLocation",
   85     85   
    ),
   86     86   
    ::aws_smithy_schema::ShapeType::Structure,
   87         -
    "coordinates",
          87  +
    "Coordinates",
   88     88   
    2,
   89     89   
);
   90     90   
static GEOPROXIMITYLOCATION_MEMBER_BIAS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   91     91   
    ::aws_smithy_schema::ShapeId::from_static(
   92     92   
        "com.amazonaws.route53#GeoProximityLocation$Bias",
   93     93   
        "com.amazonaws.route53",
   94     94   
        "GeoProximityLocation",
   95     95   
    ),
   96     96   
    ::aws_smithy_schema::ShapeType::Integer,
   97         -
    "bias",
          97  +
    "Bias",
   98     98   
    3,
   99     99   
);
  100    100   
static GEOPROXIMITYLOCATION_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  101    101   
    GEOPROXIMITYLOCATION_SCHEMA_ID,
  102    102   
    ::aws_smithy_schema::ShapeType::Structure,
  103    103   
    &[
  104    104   
        &GEOPROXIMITYLOCATION_MEMBER_AWS_REGION,
  105    105   
        &GEOPROXIMITYLOCATION_MEMBER_LOCAL_ZONE_GROUP,
  106    106   
        &GEOPROXIMITYLOCATION_MEMBER_COORDINATES,
  107    107   
        &GEOPROXIMITYLOCATION_MEMBER_BIAS,
  108    108   
    ],
  109    109   
);
  110    110   
impl GeoProximityLocation {
  111    111   
    /// The schema for this shape.
  112    112   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GEOPROXIMITYLOCATION_SCHEMA;
  113    113   
}
  114    114   
impl ::aws_smithy_schema::serde::SerializableStruct for GeoProximityLocation {
  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.aws_region {
  121    121   
            ser.write_string(&GEOPROXIMITYLOCATION_MEMBER_AWS_REGION, val)?;
  122    122   
        }
  123    123   
        if let Some(ref val) = self.local_zone_group {
  124    124   
            ser.write_string(&GEOPROXIMITYLOCATION_MEMBER_LOCAL_ZONE_GROUP, val)?;
  125    125   
        }
  126    126   
        if let Some(ref val) = self.coordinates {
  127    127   
            ser.write_struct(&GEOPROXIMITYLOCATION_MEMBER_COORDINATES, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.bias {
  130    130   
            ser.write_integer(&GEOPROXIMITYLOCATION_MEMBER_BIAS, *val)?;
  131    131   
        }
  132    132   
        Ok(())
  133    133   
    }
  134    134   
}
  135    135   
impl GeoProximityLocation {
  136    136   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  137         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  138         -
        deserializer: &mut D,
         137  +
    pub fn deserialize(
         138  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  139    139   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  140    140   
        #[allow(unused_variables, unused_mut)]
  141    141   
        let mut builder = Self::builder();
  142    142   
        #[allow(
  143    143   
            unused_variables,
  144    144   
            unreachable_code,
  145    145   
            clippy::single_match,
  146    146   
            clippy::match_single_binding,
  147    147   
            clippy::diverging_sub_expression
  148    148   
        )]
  149         -
        deserializer.read_struct(&GEOPROXIMITYLOCATION_SCHEMA, (), |_, member, deser| {
         149  +
        deserializer.read_struct(&GEOPROXIMITYLOCATION_SCHEMA, &mut |member, deser| {
  150    150   
            match member.member_index() {
  151    151   
                Some(0) => {
  152    152   
                    builder.aws_region = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                Some(1) => {
  155    155   
                    builder.local_zone_group = Some(deser.read_string(member)?);
  156    156   
                }
  157    157   
                Some(2) => {
  158    158   
                    builder.coordinates = Some(crate::types::Coordinates::deserialize(deser)?);
  159    159   
                }
  160    160   
                Some(3) => {
  161    161   
                    builder.bias = Some(deser.read_integer(member)?);
  162    162   
                }
  163    163   
                _ => {}
  164    164   
            }
  165    165   
            Ok(())
  166    166   
        })?;
  167    167   
        Ok(builder.build())
  168    168   
    }
  169    169   
}
         170  +
impl GeoProximityLocation {
         171  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         172  +
    pub fn deserialize_with_response(
         173  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         174  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         175  +
        _status: u16,
         176  +
        _body: &[u8],
         177  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         178  +
        Self::deserialize(deserializer)
         179  +
    }
         180  +
}
  170    181   
impl GeoProximityLocation {
  171    182   
    /// Creates a new builder-style object to manufacture [`GeoProximityLocation`](crate::types::GeoProximityLocation).
  172    183   
    pub fn builder() -> crate::types::builders::GeoProximityLocationBuilder {
  173    184   
        crate::types::builders::GeoProximityLocationBuilder::default()
  174    185   
    }
  175    186   
}
  176    187   
  177    188   
/// A builder for [`GeoProximityLocation`](crate::types::GeoProximityLocation).
  178    189   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  179    190   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_health_check.rs

@@ -23,23 +220,234 @@
   43     43   
    /// <p>A complex type that contains information about the CloudWatch alarm that Amazon Route 53 is monitoring for this health check.</p>
   44     44   
    pub fn cloud_watch_alarm_configuration(&self) -> ::std::option::Option<&crate::types::CloudWatchAlarmConfiguration> {
   45     45   
        self.cloud_watch_alarm_configuration.as_ref()
   46     46   
    }
   47     47   
}
   48     48   
static HEALTHCHECK_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   49     49   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HealthCheck", "com.amazonaws.route53", "HealthCheck");
   50     50   
static HEALTHCHECK_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   51     51   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HealthCheck$Id", "com.amazonaws.route53", "HealthCheck"),
   52     52   
    ::aws_smithy_schema::ShapeType::String,
   53         -
    "id",
          53  +
    "Id",
   54     54   
    0,
   55     55   
);
   56     56   
static HEALTHCHECK_MEMBER_CALLER_REFERENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.route53#HealthCheck$CallerReference",
   59     59   
        "com.amazonaws.route53",
   60     60   
        "HealthCheck",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::String,
   63         -
    "caller_reference",
          63  +
    "CallerReference",
   64     64   
    1,
   65     65   
);
   66     66   
static HEALTHCHECK_MEMBER_LINKED_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HealthCheck$LinkedService", "com.amazonaws.route53", "HealthCheck"),
   68     68   
    ::aws_smithy_schema::ShapeType::Structure,
   69         -
    "linked_service",
          69  +
    "LinkedService",
   70     70   
    2,
   71     71   
);
   72     72   
static HEALTHCHECK_MEMBER_HEALTH_CHECK_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   73     73   
    ::aws_smithy_schema::ShapeId::from_static(
   74     74   
        "com.amazonaws.route53#HealthCheck$HealthCheckConfig",
   75     75   
        "com.amazonaws.route53",
   76     76   
        "HealthCheck",
   77     77   
    ),
   78     78   
    ::aws_smithy_schema::ShapeType::Structure,
   79         -
    "health_check_config",
          79  +
    "HealthCheckConfig",
   80     80   
    3,
   81     81   
);
   82     82   
static HEALTHCHECK_MEMBER_HEALTH_CHECK_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   83     83   
    ::aws_smithy_schema::ShapeId::from_static(
   84     84   
        "com.amazonaws.route53#HealthCheck$HealthCheckVersion",
   85     85   
        "com.amazonaws.route53",
   86     86   
        "HealthCheck",
   87     87   
    ),
   88     88   
    ::aws_smithy_schema::ShapeType::Long,
   89         -
    "health_check_version",
          89  +
    "HealthCheckVersion",
   90     90   
    4,
   91     91   
);
   92     92   
static HEALTHCHECK_MEMBER_CLOUD_WATCH_ALARM_CONFIGURATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   93     93   
    ::aws_smithy_schema::ShapeId::from_static(
   94     94   
        "com.amazonaws.route53#HealthCheck$CloudWatchAlarmConfiguration",
   95     95   
        "com.amazonaws.route53",
   96     96   
        "HealthCheck",
   97     97   
    ),
   98     98   
    ::aws_smithy_schema::ShapeType::Structure,
   99         -
    "cloud_watch_alarm_configuration",
          99  +
    "CloudWatchAlarmConfiguration",
  100    100   
    5,
  101    101   
);
  102    102   
static HEALTHCHECK_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  103    103   
    HEALTHCHECK_SCHEMA_ID,
  104    104   
    ::aws_smithy_schema::ShapeType::Structure,
  105    105   
    &[
  106    106   
        &HEALTHCHECK_MEMBER_ID,
  107    107   
        &HEALTHCHECK_MEMBER_CALLER_REFERENCE,
  108    108   
        &HEALTHCHECK_MEMBER_LINKED_SERVICE,
  109    109   
        &HEALTHCHECK_MEMBER_HEALTH_CHECK_CONFIG,
  110    110   
        &HEALTHCHECK_MEMBER_HEALTH_CHECK_VERSION,
  111    111   
        &HEALTHCHECK_MEMBER_CLOUD_WATCH_ALARM_CONFIGURATION,
  112    112   
    ],
  113    113   
);
  114    114   
impl HealthCheck {
  115    115   
    /// The schema for this shape.
  116    116   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HEALTHCHECK_SCHEMA;
  117    117   
}
  118    118   
impl ::aws_smithy_schema::serde::SerializableStruct for HealthCheck {
  119    119   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  120    120   
    fn serialize_members(
  121    121   
        &self,
  122    122   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  123    123   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  124    124   
        {
  125    125   
            let val = &self.id;
  126    126   
            ser.write_string(&HEALTHCHECK_MEMBER_ID, val)?;
  127    127   
        }
  128    128   
        {
  129    129   
            let val = &self.caller_reference;
  130    130   
            ser.write_string(&HEALTHCHECK_MEMBER_CALLER_REFERENCE, val)?;
  131    131   
        }
  132    132   
        if let Some(ref val) = self.linked_service {
  133    133   
            ser.write_struct(&HEALTHCHECK_MEMBER_LINKED_SERVICE, val)?;
  134    134   
        }
  135    135   
        if let Some(ref val) = self.health_check_config {
  136    136   
            ser.write_struct(&HEALTHCHECK_MEMBER_HEALTH_CHECK_CONFIG, val)?;
  137    137   
        }
  138    138   
        {
  139    139   
            let val = &self.health_check_version;
  140    140   
            ser.write_long(&HEALTHCHECK_MEMBER_HEALTH_CHECK_VERSION, *val)?;
  141    141   
        }
  142    142   
        if let Some(ref val) = self.cloud_watch_alarm_configuration {
  143    143   
            ser.write_struct(&HEALTHCHECK_MEMBER_CLOUD_WATCH_ALARM_CONFIGURATION, val)?;
  144    144   
        }
  145    145   
        Ok(())
  146    146   
    }
  147    147   
}
  148    148   
impl HealthCheck {
  149    149   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  150         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  151         -
        deserializer: &mut D,
         150  +
    pub fn deserialize(
         151  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  152    152   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  153    153   
        #[allow(unused_variables, unused_mut)]
  154    154   
        let mut builder = Self::builder();
  155    155   
        #[allow(
  156    156   
            unused_variables,
  157    157   
            unreachable_code,
  158    158   
            clippy::single_match,
  159    159   
            clippy::match_single_binding,
  160    160   
            clippy::diverging_sub_expression
  161    161   
        )]
  162         -
        deserializer.read_struct(&HEALTHCHECK_SCHEMA, (), |_, member, deser| {
         162  +
        deserializer.read_struct(&HEALTHCHECK_SCHEMA, &mut |member, deser| {
  163    163   
            match member.member_index() {
  164    164   
                Some(0) => {
  165    165   
                    builder.id = Some(deser.read_string(member)?);
  166    166   
                }
  167    167   
                Some(1) => {
  168    168   
                    builder.caller_reference = Some(deser.read_string(member)?);
  169    169   
                }
  170    170   
                Some(2) => {
  171    171   
                    builder.linked_service = Some(crate::types::LinkedService::deserialize(deser)?);
  172    172   
                }
  173    173   
                Some(3) => {
  174    174   
                    builder.health_check_config = Some(crate::types::HealthCheckConfig::deserialize(deser)?);
  175    175   
                }
  176    176   
                Some(4) => {
  177    177   
                    builder.health_check_version = Some(deser.read_long(member)?);
  178    178   
                }
  179    179   
                Some(5) => {
  180    180   
                    builder.cloud_watch_alarm_configuration = Some(crate::types::CloudWatchAlarmConfiguration::deserialize(deser)?);
  181    181   
                }
  182    182   
                _ => {}
  183    183   
            }
  184    184   
            Ok(())
  185    185   
        })?;
         186  +
        builder.id = builder.id.or(Some(String::new()));
         187  +
        builder.caller_reference = builder.caller_reference.or(Some(String::new()));
         188  +
        builder.health_check_version = builder.health_check_version.or(Some(0i64));
  186    189   
        builder
  187    190   
            .build()
  188    191   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  189    192   
    }
  190    193   
}
         194  +
impl HealthCheck {
         195  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         196  +
    pub fn deserialize_with_response(
         197  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         198  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         199  +
        _status: u16,
         200  +
        _body: &[u8],
         201  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         202  +
        Self::deserialize(deserializer)
         203  +
    }
         204  +
}
  191    205   
impl HealthCheck {
  192    206   
    /// Creates a new builder-style object to manufacture [`HealthCheck`](crate::types::HealthCheck).
  193    207   
    pub fn builder() -> crate::types::builders::HealthCheckBuilder {
  194    208   
        crate::types::builders::HealthCheckBuilder::default()
  195    209   
    }
  196    210   
}
  197    211   
  198    212   
/// A builder for [`HealthCheck`](crate::types::HealthCheck).
  199    213   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  200    214   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_health_check_config.rs

@@ -305,305 +535,535 @@
  325    325   
}
  326    326   
static HEALTHCHECKCONFIG_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  327    327   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HealthCheckConfig", "com.amazonaws.route53", "HealthCheckConfig");
  328    328   
static HEALTHCHECKCONFIG_MEMBER_IP_ADDRESS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  329    329   
    ::aws_smithy_schema::ShapeId::from_static(
  330    330   
        "com.amazonaws.route53#HealthCheckConfig$IPAddress",
  331    331   
        "com.amazonaws.route53",
  332    332   
        "HealthCheckConfig",
  333    333   
    ),
  334    334   
    ::aws_smithy_schema::ShapeType::String,
  335         -
    "ip_address",
         335  +
    "IPAddress",
  336    336   
    0,
  337    337   
);
  338    338   
static HEALTHCHECKCONFIG_MEMBER_PORT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  339    339   
    ::aws_smithy_schema::ShapeId::from_static(
  340    340   
        "com.amazonaws.route53#HealthCheckConfig$Port",
  341    341   
        "com.amazonaws.route53",
  342    342   
        "HealthCheckConfig",
  343    343   
    ),
  344    344   
    ::aws_smithy_schema::ShapeType::Integer,
  345         -
    "port",
         345  +
    "Port",
  346    346   
    1,
  347    347   
);
  348    348   
static HEALTHCHECKCONFIG_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  349    349   
    ::aws_smithy_schema::ShapeId::from_static(
  350    350   
        "com.amazonaws.route53#HealthCheckConfig$Type",
  351    351   
        "com.amazonaws.route53",
  352    352   
        "HealthCheckConfig",
  353    353   
    ),
  354    354   
    ::aws_smithy_schema::ShapeType::String,
  355         -
    "r##type",
         355  +
    "Type",
  356    356   
    2,
  357    357   
);
  358    358   
static HEALTHCHECKCONFIG_MEMBER_RESOURCE_PATH: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  359    359   
    ::aws_smithy_schema::ShapeId::from_static(
  360    360   
        "com.amazonaws.route53#HealthCheckConfig$ResourcePath",
  361    361   
        "com.amazonaws.route53",
  362    362   
        "HealthCheckConfig",
  363    363   
    ),
  364    364   
    ::aws_smithy_schema::ShapeType::String,
  365         -
    "resource_path",
         365  +
    "ResourcePath",
  366    366   
    3,
  367    367   
);
  368    368   
static HEALTHCHECKCONFIG_MEMBER_FULLY_QUALIFIED_DOMAIN_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  369    369   
    ::aws_smithy_schema::ShapeId::from_static(
  370    370   
        "com.amazonaws.route53#HealthCheckConfig$FullyQualifiedDomainName",
  371    371   
        "com.amazonaws.route53",
  372    372   
        "HealthCheckConfig",
  373    373   
    ),
  374    374   
    ::aws_smithy_schema::ShapeType::String,
  375         -
    "fully_qualified_domain_name",
         375  +
    "FullyQualifiedDomainName",
  376    376   
    4,
  377    377   
);
  378    378   
static HEALTHCHECKCONFIG_MEMBER_SEARCH_STRING: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static(
  380    380   
        "com.amazonaws.route53#HealthCheckConfig$SearchString",
  381    381   
        "com.amazonaws.route53",
  382    382   
        "HealthCheckConfig",
  383    383   
    ),
  384    384   
    ::aws_smithy_schema::ShapeType::String,
  385         -
    "search_string",
         385  +
    "SearchString",
  386    386   
    5,
  387    387   
);
  388    388   
static HEALTHCHECKCONFIG_MEMBER_REQUEST_INTERVAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  389    389   
    ::aws_smithy_schema::ShapeId::from_static(
  390    390   
        "com.amazonaws.route53#HealthCheckConfig$RequestInterval",
  391    391   
        "com.amazonaws.route53",
  392    392   
        "HealthCheckConfig",
  393    393   
    ),
  394    394   
    ::aws_smithy_schema::ShapeType::Integer,
  395         -
    "request_interval",
         395  +
    "RequestInterval",
  396    396   
    6,
  397    397   
);
  398    398   
static HEALTHCHECKCONFIG_MEMBER_FAILURE_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  399    399   
    ::aws_smithy_schema::ShapeId::from_static(
  400    400   
        "com.amazonaws.route53#HealthCheckConfig$FailureThreshold",
  401    401   
        "com.amazonaws.route53",
  402    402   
        "HealthCheckConfig",
  403    403   
    ),
  404    404   
    ::aws_smithy_schema::ShapeType::Integer,
  405         -
    "failure_threshold",
         405  +
    "FailureThreshold",
  406    406   
    7,
  407    407   
);
  408    408   
static HEALTHCHECKCONFIG_MEMBER_MEASURE_LATENCY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  409    409   
    ::aws_smithy_schema::ShapeId::from_static(
  410    410   
        "com.amazonaws.route53#HealthCheckConfig$MeasureLatency",
  411    411   
        "com.amazonaws.route53",
  412    412   
        "HealthCheckConfig",
  413    413   
    ),
  414    414   
    ::aws_smithy_schema::ShapeType::Boolean,
  415         -
    "measure_latency",
         415  +
    "MeasureLatency",
  416    416   
    8,
  417    417   
);
  418    418   
static HEALTHCHECKCONFIG_MEMBER_INVERTED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  419    419   
    ::aws_smithy_schema::ShapeId::from_static(
  420    420   
        "com.amazonaws.route53#HealthCheckConfig$Inverted",
  421    421   
        "com.amazonaws.route53",
  422    422   
        "HealthCheckConfig",
  423    423   
    ),
  424    424   
    ::aws_smithy_schema::ShapeType::Boolean,
  425         -
    "inverted",
         425  +
    "Inverted",
  426    426   
    9,
  427    427   
);
  428    428   
static HEALTHCHECKCONFIG_MEMBER_DISABLED: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  429    429   
    ::aws_smithy_schema::ShapeId::from_static(
  430    430   
        "com.amazonaws.route53#HealthCheckConfig$Disabled",
  431    431   
        "com.amazonaws.route53",
  432    432   
        "HealthCheckConfig",
  433    433   
    ),
  434    434   
    ::aws_smithy_schema::ShapeType::Boolean,
  435         -
    "disabled",
         435  +
    "Disabled",
  436    436   
    10,
  437    437   
);
  438    438   
static HEALTHCHECKCONFIG_MEMBER_HEALTH_THRESHOLD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  439    439   
    ::aws_smithy_schema::ShapeId::from_static(
  440    440   
        "com.amazonaws.route53#HealthCheckConfig$HealthThreshold",
  441    441   
        "com.amazonaws.route53",
  442    442   
        "HealthCheckConfig",
  443    443   
    ),
  444    444   
    ::aws_smithy_schema::ShapeType::Integer,
  445         -
    "health_threshold",
         445  +
    "HealthThreshold",
  446    446   
    11,
  447    447   
);
  448    448   
static HEALTHCHECKCONFIG_MEMBER_CHILD_HEALTH_CHECKS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  449    449   
    ::aws_smithy_schema::ShapeId::from_static(
  450    450   
        "com.amazonaws.route53#HealthCheckConfig$ChildHealthChecks",
  451    451   
        "com.amazonaws.route53",
  452    452   
        "HealthCheckConfig",
  453    453   
    ),
  454    454   
    ::aws_smithy_schema::ShapeType::List,
  455         -
    "child_health_checks",
         455  +
    "ChildHealthChecks",
  456    456   
    12,
  457    457   
);
  458    458   
static HEALTHCHECKCONFIG_MEMBER_ENABLE_SNI: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  459    459   
    ::aws_smithy_schema::ShapeId::from_static(
  460    460   
        "com.amazonaws.route53#HealthCheckConfig$EnableSNI",
  461    461   
        "com.amazonaws.route53",
  462    462   
        "HealthCheckConfig",
  463    463   
    ),
  464    464   
    ::aws_smithy_schema::ShapeType::Boolean,
  465         -
    "enable_sni",
         465  +
    "EnableSNI",
  466    466   
    13,
  467    467   
);
  468    468   
static HEALTHCHECKCONFIG_MEMBER_REGIONS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  469    469   
    ::aws_smithy_schema::ShapeId::from_static(
  470    470   
        "com.amazonaws.route53#HealthCheckConfig$Regions",
  471    471   
        "com.amazonaws.route53",
  472    472   
        "HealthCheckConfig",
  473    473   
    ),
  474    474   
    ::aws_smithy_schema::ShapeType::List,
  475         -
    "regions",
         475  +
    "Regions",
  476    476   
    14,
  477    477   
);
  478    478   
static HEALTHCHECKCONFIG_MEMBER_ALARM_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  479    479   
    ::aws_smithy_schema::ShapeId::from_static(
  480    480   
        "com.amazonaws.route53#HealthCheckConfig$AlarmIdentifier",
  481    481   
        "com.amazonaws.route53",
  482    482   
        "HealthCheckConfig",
  483    483   
    ),
  484    484   
    ::aws_smithy_schema::ShapeType::Structure,
  485         -
    "alarm_identifier",
         485  +
    "AlarmIdentifier",
  486    486   
    15,
  487    487   
);
  488    488   
static HEALTHCHECKCONFIG_MEMBER_INSUFFICIENT_DATA_HEALTH_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  489    489   
    ::aws_smithy_schema::ShapeId::from_static(
  490    490   
        "com.amazonaws.route53#HealthCheckConfig$InsufficientDataHealthStatus",
  491    491   
        "com.amazonaws.route53",
  492    492   
        "HealthCheckConfig",
  493    493   
    ),
  494    494   
    ::aws_smithy_schema::ShapeType::String,
  495         -
    "insufficient_data_health_status",
         495  +
    "InsufficientDataHealthStatus",
  496    496   
    16,
  497    497   
);
  498    498   
static HEALTHCHECKCONFIG_MEMBER_ROUTING_CONTROL_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  499    499   
    ::aws_smithy_schema::ShapeId::from_static(
  500    500   
        "com.amazonaws.route53#HealthCheckConfig$RoutingControlArn",
  501    501   
        "com.amazonaws.route53",
  502    502   
        "HealthCheckConfig",
  503    503   
    ),
  504    504   
    ::aws_smithy_schema::ShapeType::String,
  505         -
    "routing_control_arn",
         505  +
    "RoutingControlArn",
  506    506   
    17,
  507    507   
);
  508    508   
static HEALTHCHECKCONFIG_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  509    509   
    HEALTHCHECKCONFIG_SCHEMA_ID,
  510    510   
    ::aws_smithy_schema::ShapeType::Structure,
  511    511   
    &[
  512    512   
        &HEALTHCHECKCONFIG_MEMBER_IP_ADDRESS,
  513    513   
        &HEALTHCHECKCONFIG_MEMBER_PORT,
  514    514   
        &HEALTHCHECKCONFIG_MEMBER_TYPE,
  515    515   
        &HEALTHCHECKCONFIG_MEMBER_RESOURCE_PATH,
@@ -588,588 +745,743 @@
  608    608   
            ser.write_string(&HEALTHCHECKCONFIG_MEMBER_INSUFFICIENT_DATA_HEALTH_STATUS, val.as_str())?;
  609    609   
        }
  610    610   
        if let Some(ref val) = self.routing_control_arn {
  611    611   
            ser.write_string(&HEALTHCHECKCONFIG_MEMBER_ROUTING_CONTROL_ARN, val)?;
  612    612   
        }
  613    613   
        Ok(())
  614    614   
    }
  615    615   
}
  616    616   
impl HealthCheckConfig {
  617    617   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  618         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  619         -
        deserializer: &mut D,
         618  +
    pub fn deserialize(
         619  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  620    620   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  621    621   
        #[allow(unused_variables, unused_mut)]
  622    622   
        let mut builder = Self::builder();
  623    623   
        #[allow(
  624    624   
            unused_variables,
  625    625   
            unreachable_code,
  626    626   
            clippy::single_match,
  627    627   
            clippy::match_single_binding,
  628    628   
            clippy::diverging_sub_expression
  629    629   
        )]
  630         -
        deserializer.read_struct(&HEALTHCHECKCONFIG_SCHEMA, (), |_, member, deser| {
         630  +
        deserializer.read_struct(&HEALTHCHECKCONFIG_SCHEMA, &mut |member, deser| {
  631    631   
            match member.member_index() {
  632    632   
                Some(0) => {
  633    633   
                    builder.ip_address = Some(deser.read_string(member)?);
  634    634   
                }
  635    635   
                Some(1) => {
  636    636   
                    builder.port = Some(deser.read_integer(member)?);
  637    637   
                }
  638    638   
                Some(2) => {
  639    639   
                    builder.r#type = Some(crate::types::HealthCheckType::from(deser.read_string(member)?.as_str()));
  640    640   
                }
  641    641   
                Some(3) => {
  642    642   
                    builder.resource_path = Some(deser.read_string(member)?);
  643    643   
                }
  644    644   
                Some(4) => {
  645    645   
                    builder.fully_qualified_domain_name = Some(deser.read_string(member)?);
  646    646   
                }
  647    647   
                Some(5) => {
  648    648   
                    builder.search_string = Some(deser.read_string(member)?);
  649    649   
                }
  650    650   
                Some(6) => {
  651    651   
                    builder.request_interval = Some(deser.read_integer(member)?);
  652    652   
                }
  653    653   
                Some(7) => {
  654    654   
                    builder.failure_threshold = Some(deser.read_integer(member)?);
  655    655   
                }
  656    656   
                Some(8) => {
  657    657   
                    builder.measure_latency = Some(deser.read_boolean(member)?);
  658    658   
                }
  659    659   
                Some(9) => {
  660    660   
                    builder.inverted = Some(deser.read_boolean(member)?);
  661    661   
                }
  662    662   
                Some(10) => {
  663    663   
                    builder.disabled = Some(deser.read_boolean(member)?);
  664    664   
                }
  665    665   
                Some(11) => {
  666    666   
                    builder.health_threshold = Some(deser.read_integer(member)?);
  667    667   
                }
  668    668   
                Some(12) => {
  669         -
                    builder.child_health_checks = Some({
  670         -
                        let container = if let Some(cap) = deser.container_size() {
  671         -
                            Vec::with_capacity(cap)
  672         -
                        } else {
  673         -
                            Vec::new()
  674         -
                        };
  675         -
                        deser.read_list(member, container, |mut list, deser| {
  676         -
                            list.push(deser.read_string(member)?);
  677         -
                            Ok(list)
  678         -
                        })?
  679         -
                    });
         669  +
                    builder.child_health_checks = Some(deser.read_string_list(member)?);
  680    670   
                }
  681    671   
                Some(13) => {
  682    672   
                    builder.enable_sni = Some(deser.read_boolean(member)?);
  683    673   
                }
  684    674   
                Some(14) => {
  685    675   
                    builder.regions = Some({
  686         -
                        let container = if let Some(cap) = deser.container_size() {
  687         -
                            Vec::with_capacity(cap)
  688         -
                        } else {
  689         -
                            Vec::new()
  690         -
                        };
  691         -
                        deser.read_list(member, container, |mut list, deser| {
  692         -
                            list.push(crate::types::HealthCheckRegion::from(deser.read_string(member)?.as_str()));
  693         -
                            Ok(list)
  694         -
                        })?
         676  +
                        let mut container = Vec::new();
         677  +
                        deser.read_list(member, &mut |deser| {
         678  +
                            container.push(crate::types::HealthCheckRegion::from(deser.read_string(member)?.as_str()));
         679  +
                            Ok(())
         680  +
                        })?;
         681  +
                        container
  695    682   
                    });
  696    683   
                }
  697    684   
                Some(15) => {
  698    685   
                    builder.alarm_identifier = Some(crate::types::AlarmIdentifier::deserialize(deser)?);
  699    686   
                }
  700    687   
                Some(16) => {
  701    688   
                    builder.insufficient_data_health_status =
  702    689   
                        Some(crate::types::InsufficientDataHealthStatus::from(deser.read_string(member)?.as_str()));
  703    690   
                }
  704    691   
                Some(17) => {
  705    692   
                    builder.routing_control_arn = Some(deser.read_string(member)?);
  706    693   
                }
  707    694   
                _ => {}
  708    695   
            }
  709    696   
            Ok(())
  710    697   
        })?;
  711    698   
        builder
  712    699   
            .build()
  713    700   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  714    701   
    }
  715    702   
}
         703  +
impl HealthCheckConfig {
         704  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         705  +
    pub fn deserialize_with_response(
         706  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         707  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         708  +
        _status: u16,
         709  +
        _body: &[u8],
         710  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         711  +
        Self::deserialize(deserializer)
         712  +
    }
         713  +
}
  716    714   
impl HealthCheckConfig {
  717    715   
    /// Creates a new builder-style object to manufacture [`HealthCheckConfig`](crate::types::HealthCheckConfig).
  718    716   
    pub fn builder() -> crate::types::builders::HealthCheckConfigBuilder {
  719    717   
        crate::types::builders::HealthCheckConfigBuilder::default()
  720    718   
    }
  721    719   
}
  722    720   
  723    721   
/// A builder for [`HealthCheckConfig`](crate::types::HealthCheckConfig).
  724    722   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  725    723   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_health_check_observation.rs

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

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_hosted_zone.rs

@@ -26,26 +211,225 @@
   46     46   
    /// <p>If the hosted zone was created by another service, the service that created the hosted zone. When a hosted zone is created by another service, you can't edit or delete it using Route 53.</p>
   47     47   
    pub fn linked_service(&self) -> ::std::option::Option<&crate::types::LinkedService> {
   48     48   
        self.linked_service.as_ref()
   49     49   
    }
   50     50   
}
   51     51   
static HOSTEDZONE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone", "com.amazonaws.route53", "HostedZone");
   53     53   
static HOSTEDZONE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   54     54   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone$Id", "com.amazonaws.route53", "HostedZone"),
   55     55   
    ::aws_smithy_schema::ShapeType::String,
   56         -
    "id",
          56  +
    "Id",
   57     57   
    0,
   58     58   
);
   59     59   
static HOSTEDZONE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   60     60   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone$Name", "com.amazonaws.route53", "HostedZone"),
   61     61   
    ::aws_smithy_schema::ShapeType::String,
   62         -
    "name",
          62  +
    "Name",
   63     63   
    1,
   64     64   
);
   65     65   
static HOSTEDZONE_MEMBER_CALLER_REFERENCE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   66     66   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone$CallerReference", "com.amazonaws.route53", "HostedZone"),
   67     67   
    ::aws_smithy_schema::ShapeType::String,
   68         -
    "caller_reference",
          68  +
    "CallerReference",
   69     69   
    2,
   70     70   
);
   71     71   
static HOSTEDZONE_MEMBER_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone$Config", "com.amazonaws.route53", "HostedZone"),
   73     73   
    ::aws_smithy_schema::ShapeType::Structure,
   74         -
    "config",
          74  +
    "Config",
   75     75   
    3,
   76     76   
);
   77     77   
static HOSTEDZONE_MEMBER_RESOURCE_RECORD_SET_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.route53#HostedZone$ResourceRecordSetCount",
   80     80   
        "com.amazonaws.route53",
   81     81   
        "HostedZone",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Long,
   84         -
    "resource_record_set_count",
          84  +
    "ResourceRecordSetCount",
   85     85   
    4,
   86     86   
);
   87     87   
static HOSTEDZONE_MEMBER_LINKED_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZone$LinkedService", "com.amazonaws.route53", "HostedZone"),
   89     89   
    ::aws_smithy_schema::ShapeType::Structure,
   90         -
    "linked_service",
          90  +
    "LinkedService",
   91     91   
    5,
   92     92   
);
   93     93   
static HOSTEDZONE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   94     94   
    HOSTEDZONE_SCHEMA_ID,
   95     95   
    ::aws_smithy_schema::ShapeType::Structure,
   96     96   
    &[
   97     97   
        &HOSTEDZONE_MEMBER_ID,
   98     98   
        &HOSTEDZONE_MEMBER_NAME,
   99     99   
        &HOSTEDZONE_MEMBER_CALLER_REFERENCE,
  100    100   
        &HOSTEDZONE_MEMBER_CONFIG,
  101    101   
        &HOSTEDZONE_MEMBER_RESOURCE_RECORD_SET_COUNT,
  102    102   
        &HOSTEDZONE_MEMBER_LINKED_SERVICE,
  103    103   
    ],
  104    104   
);
  105    105   
impl HostedZone {
  106    106   
    /// The schema for this shape.
  107    107   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HOSTEDZONE_SCHEMA;
  108    108   
}
  109    109   
impl ::aws_smithy_schema::serde::SerializableStruct for HostedZone {
  110    110   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  111    111   
    fn serialize_members(
  112    112   
        &self,
  113    113   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  114    114   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  115    115   
        {
  116    116   
            let val = &self.id;
  117    117   
            ser.write_string(&HOSTEDZONE_MEMBER_ID, val)?;
  118    118   
        }
  119    119   
        {
  120    120   
            let val = &self.name;
  121    121   
            ser.write_string(&HOSTEDZONE_MEMBER_NAME, val)?;
  122    122   
        }
  123    123   
        {
  124    124   
            let val = &self.caller_reference;
  125    125   
            ser.write_string(&HOSTEDZONE_MEMBER_CALLER_REFERENCE, val)?;
  126    126   
        }
  127    127   
        if let Some(ref val) = self.config {
  128    128   
            ser.write_struct(&HOSTEDZONE_MEMBER_CONFIG, val)?;
  129    129   
        }
  130    130   
        if let Some(ref val) = self.resource_record_set_count {
  131    131   
            ser.write_long(&HOSTEDZONE_MEMBER_RESOURCE_RECORD_SET_COUNT, *val)?;
  132    132   
        }
  133    133   
        if let Some(ref val) = self.linked_service {
  134    134   
            ser.write_struct(&HOSTEDZONE_MEMBER_LINKED_SERVICE, val)?;
  135    135   
        }
  136    136   
        Ok(())
  137    137   
    }
  138    138   
}
  139    139   
impl HostedZone {
  140    140   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  141         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  142         -
        deserializer: &mut D,
         141  +
    pub fn deserialize(
         142  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  143    143   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  144    144   
        #[allow(unused_variables, unused_mut)]
  145    145   
        let mut builder = Self::builder();
  146    146   
        #[allow(
  147    147   
            unused_variables,
  148    148   
            unreachable_code,
  149    149   
            clippy::single_match,
  150    150   
            clippy::match_single_binding,
  151    151   
            clippy::diverging_sub_expression
  152    152   
        )]
  153         -
        deserializer.read_struct(&HOSTEDZONE_SCHEMA, (), |_, member, deser| {
         153  +
        deserializer.read_struct(&HOSTEDZONE_SCHEMA, &mut |member, deser| {
  154    154   
            match member.member_index() {
  155    155   
                Some(0) => {
  156    156   
                    builder.id = Some(deser.read_string(member)?);
  157    157   
                }
  158    158   
                Some(1) => {
  159    159   
                    builder.name = Some(deser.read_string(member)?);
  160    160   
                }
  161    161   
                Some(2) => {
  162    162   
                    builder.caller_reference = Some(deser.read_string(member)?);
  163    163   
                }
  164    164   
                Some(3) => {
  165    165   
                    builder.config = Some(crate::types::HostedZoneConfig::deserialize(deser)?);
  166    166   
                }
  167    167   
                Some(4) => {
  168    168   
                    builder.resource_record_set_count = Some(deser.read_long(member)?);
  169    169   
                }
  170    170   
                Some(5) => {
  171    171   
                    builder.linked_service = Some(crate::types::LinkedService::deserialize(deser)?);
  172    172   
                }
  173    173   
                _ => {}
  174    174   
            }
  175    175   
            Ok(())
  176    176   
        })?;
         177  +
        builder.id = builder.id.or(Some(String::new()));
         178  +
        builder.name = builder.name.or(Some(String::new()));
         179  +
        builder.caller_reference = builder.caller_reference.or(Some(String::new()));
  177    180   
        builder
  178    181   
            .build()
  179    182   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  180    183   
    }
  181    184   
}
         185  +
impl HostedZone {
         186  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         187  +
    pub fn deserialize_with_response(
         188  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         189  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         190  +
        _status: u16,
         191  +
        _body: &[u8],
         192  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         193  +
        Self::deserialize(deserializer)
         194  +
    }
         195  +
}
  182    196   
impl HostedZone {
  183    197   
    /// Creates a new builder-style object to manufacture [`HostedZone`](crate::types::HostedZone).
  184    198   
    pub fn builder() -> crate::types::builders::HostedZoneBuilder {
  185    199   
        crate::types::builders::HostedZoneBuilder::default()
  186    200   
    }
  187    201   
}
  188    202   
  189    203   
/// A builder for [`HostedZone`](crate::types::HostedZone).
  190    204   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  191    205   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/route53/src/types/_hosted_zone_config.rs

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