AWS SDK

AWS SDK

rev. ec7b2441254af868911fccffe8d8dca83aff0045 (ignoring whitespace)

Files changed:

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]

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

@@ -9,9 +134,146 @@
   29     29   
    /// <p>The current value for the limit that is specified by <code>Type</code>.</p>
   30     30   
    pub fn value(&self) -> i64 {
   31     31   
        self.value
   32     32   
    }
   33     33   
}
   34     34   
static HOSTEDZONELIMIT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   35     35   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZoneLimit", "com.amazonaws.route53", "HostedZoneLimit");
   36     36   
static HOSTEDZONELIMIT_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   37     37   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZoneLimit$Type", "com.amazonaws.route53", "HostedZoneLimit"),
   38     38   
    ::aws_smithy_schema::ShapeType::String,
   39         -
    "r##type",
          39  +
    "Type",
   40     40   
    0,
   41     41   
);
   42     42   
static HOSTEDZONELIMIT_MEMBER_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZoneLimit$Value", "com.amazonaws.route53", "HostedZoneLimit"),
   44     44   
    ::aws_smithy_schema::ShapeType::Long,
   45         -
    "value",
          45  +
    "Value",
   46     46   
    1,
   47     47   
);
   48     48   
static HOSTEDZONELIMIT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   49     49   
    HOSTEDZONELIMIT_SCHEMA_ID,
   50     50   
    ::aws_smithy_schema::ShapeType::Structure,
   51     51   
    &[&HOSTEDZONELIMIT_MEMBER_TYPE, &HOSTEDZONELIMIT_MEMBER_VALUE],
   52     52   
);
   53     53   
impl HostedZoneLimit {
   54     54   
    /// The schema for this shape.
   55     55   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HOSTEDZONELIMIT_SCHEMA;
   56     56   
}
   57     57   
impl ::aws_smithy_schema::serde::SerializableStruct for HostedZoneLimit {
   58     58   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   59     59   
    fn serialize_members(
   60     60   
        &self,
   61     61   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   62     62   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   63     63   
        {
   64     64   
            let val = &self.r#type;
   65     65   
            ser.write_string(&HOSTEDZONELIMIT_MEMBER_TYPE, val.as_str())?;
   66     66   
        }
   67     67   
        {
   68     68   
            let val = &self.value;
   69     69   
            ser.write_long(&HOSTEDZONELIMIT_MEMBER_VALUE, *val)?;
   70     70   
        }
   71     71   
        Ok(())
   72     72   
    }
   73     73   
}
   74     74   
impl HostedZoneLimit {
   75     75   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   76         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   77         -
        deserializer: &mut D,
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   78     78   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   79     79   
        #[allow(unused_variables, unused_mut)]
   80     80   
        let mut builder = Self::builder();
   81     81   
        #[allow(
   82     82   
            unused_variables,
   83     83   
            unreachable_code,
   84     84   
            clippy::single_match,
   85     85   
            clippy::match_single_binding,
   86     86   
            clippy::diverging_sub_expression
   87     87   
        )]
   88         -
        deserializer.read_struct(&HOSTEDZONELIMIT_SCHEMA, (), |_, member, deser| {
          88  +
        deserializer.read_struct(&HOSTEDZONELIMIT_SCHEMA, &mut |member, deser| {
   89     89   
            match member.member_index() {
   90     90   
                Some(0) => {
   91     91   
                    builder.r#type = Some(crate::types::HostedZoneLimitType::from(deser.read_string(member)?.as_str()));
   92     92   
                }
   93     93   
                Some(1) => {
   94     94   
                    builder.value = Some(deser.read_long(member)?);
   95     95   
                }
   96     96   
                _ => {}
   97     97   
            }
   98     98   
            Ok(())
   99     99   
        })?;
         100  +
        builder.value = builder.value.or(Some(0i64));
  100    101   
        builder
  101    102   
            .build()
  102    103   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  103    104   
    }
  104    105   
}
         106  +
impl HostedZoneLimit {
         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  +
}
  105    117   
impl HostedZoneLimit {
  106    118   
    /// Creates a new builder-style object to manufacture [`HostedZoneLimit`](crate::types::HostedZoneLimit).
  107    119   
    pub fn builder() -> crate::types::builders::HostedZoneLimitBuilder {
  108    120   
        crate::types::builders::HostedZoneLimitBuilder::default()
  109    121   
    }
  110    122   
}
  111    123   
  112    124   
/// A builder for [`HostedZoneLimit`](crate::types::HostedZoneLimit).
  113    125   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  114    126   
#[non_exhaustive]

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

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static HOSTEDZONEOWNER_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#HostedZoneOwner", "com.amazonaws.route53", "HostedZoneOwner");
   24     24   
static HOSTEDZONEOWNER_MEMBER_OWNING_ACCOUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.route53#HostedZoneOwner$OwningAccount",
   27     27   
        "com.amazonaws.route53",
   28     28   
        "HostedZoneOwner",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "owning_account",
          31  +
    "OwningAccount",
   32     32   
    0,
   33     33   
);
   34     34   
static HOSTEDZONEOWNER_MEMBER_OWNING_SERVICE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.route53#HostedZoneOwner$OwningService",
   37     37   
        "com.amazonaws.route53",
   38     38   
        "HostedZoneOwner",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "owning_service",
          41  +
    "OwningService",
   42     42   
    1,
   43     43   
);
   44     44   
static HOSTEDZONEOWNER_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    HOSTEDZONEOWNER_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&HOSTEDZONEOWNER_MEMBER_OWNING_ACCOUNT, &HOSTEDZONEOWNER_MEMBER_OWNING_SERVICE],
   48     48   
);
   49     49   
impl HostedZoneOwner {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &HOSTEDZONEOWNER_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for HostedZoneOwner {
   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.owning_account {
   60     60   
            ser.write_string(&HOSTEDZONEOWNER_MEMBER_OWNING_ACCOUNT, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.owning_service {
   63     63   
            ser.write_string(&HOSTEDZONEOWNER_MEMBER_OWNING_SERVICE, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl HostedZoneOwner {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&HOSTEDZONEOWNER_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&HOSTEDZONEOWNER_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.owning_account = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.owning_service = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl HostedZoneOwner {
          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  +
}
   97    108   
impl HostedZoneOwner {
   98    109   
    /// Creates a new builder-style object to manufacture [`HostedZoneOwner`](crate::types::HostedZoneOwner).
   99    110   
    pub fn builder() -> crate::types::builders::HostedZoneOwnerBuilder {
  100    111   
        crate::types::builders::HostedZoneOwnerBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`HostedZoneOwner`](crate::types::HostedZoneOwner).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]

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

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

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

@@ -229,229 +415,415 @@
  249    249   
    /// <p>The last time that the key-signing key (KSK) was changed.</p>
  250    250   
    pub fn last_modified_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
  251    251   
        self.last_modified_date.as_ref()
  252    252   
    }
  253    253   
}
  254    254   
static KEYSIGNINGKEY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  255    255   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey", "com.amazonaws.route53", "KeySigningKey");
  256    256   
static KEYSIGNINGKEY_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  257    257   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$Name", "com.amazonaws.route53", "KeySigningKey"),
  258    258   
    ::aws_smithy_schema::ShapeType::String,
  259         -
    "name",
         259  +
    "Name",
  260    260   
    0,
  261    261   
);
  262    262   
static KEYSIGNINGKEY_MEMBER_KMS_ARN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  263    263   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$KmsArn", "com.amazonaws.route53", "KeySigningKey"),
  264    264   
    ::aws_smithy_schema::ShapeType::String,
  265         -
    "kms_arn",
         265  +
    "KmsArn",
  266    266   
    1,
  267    267   
);
  268    268   
static KEYSIGNINGKEY_MEMBER_FLAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  269    269   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$Flag", "com.amazonaws.route53", "KeySigningKey"),
  270    270   
    ::aws_smithy_schema::ShapeType::Integer,
  271         -
    "flag",
         271  +
    "Flag",
  272    272   
    2,
  273    273   
);
  274    274   
static KEYSIGNINGKEY_MEMBER_SIGNING_ALGORITHM_MNEMONIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  275    275   
    ::aws_smithy_schema::ShapeId::from_static(
  276    276   
        "com.amazonaws.route53#KeySigningKey$SigningAlgorithmMnemonic",
  277    277   
        "com.amazonaws.route53",
  278    278   
        "KeySigningKey",
  279    279   
    ),
  280    280   
    ::aws_smithy_schema::ShapeType::String,
  281         -
    "signing_algorithm_mnemonic",
         281  +
    "SigningAlgorithmMnemonic",
  282    282   
    3,
  283    283   
);
  284    284   
static KEYSIGNINGKEY_MEMBER_SIGNING_ALGORITHM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  285    285   
    ::aws_smithy_schema::ShapeId::from_static(
  286    286   
        "com.amazonaws.route53#KeySigningKey$SigningAlgorithmType",
  287    287   
        "com.amazonaws.route53",
  288    288   
        "KeySigningKey",
  289    289   
    ),
  290    290   
    ::aws_smithy_schema::ShapeType::Integer,
  291         -
    "signing_algorithm_type",
         291  +
    "SigningAlgorithmType",
  292    292   
    4,
  293    293   
);
  294    294   
static KEYSIGNINGKEY_MEMBER_DIGEST_ALGORITHM_MNEMONIC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  295    295   
    ::aws_smithy_schema::ShapeId::from_static(
  296    296   
        "com.amazonaws.route53#KeySigningKey$DigestAlgorithmMnemonic",
  297    297   
        "com.amazonaws.route53",
  298    298   
        "KeySigningKey",
  299    299   
    ),
  300    300   
    ::aws_smithy_schema::ShapeType::String,
  301         -
    "digest_algorithm_mnemonic",
         301  +
    "DigestAlgorithmMnemonic",
  302    302   
    5,
  303    303   
);
  304    304   
static KEYSIGNINGKEY_MEMBER_DIGEST_ALGORITHM_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  305    305   
    ::aws_smithy_schema::ShapeId::from_static(
  306    306   
        "com.amazonaws.route53#KeySigningKey$DigestAlgorithmType",
  307    307   
        "com.amazonaws.route53",
  308    308   
        "KeySigningKey",
  309    309   
    ),
  310    310   
    ::aws_smithy_schema::ShapeType::Integer,
  311         -
    "digest_algorithm_type",
         311  +
    "DigestAlgorithmType",
  312    312   
    6,
  313    313   
);
  314    314   
static KEYSIGNINGKEY_MEMBER_KEY_TAG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  315    315   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$KeyTag", "com.amazonaws.route53", "KeySigningKey"),
  316    316   
    ::aws_smithy_schema::ShapeType::Integer,
  317         -
    "key_tag",
         317  +
    "KeyTag",
  318    318   
    7,
  319    319   
);
  320    320   
static KEYSIGNINGKEY_MEMBER_DIGEST_VALUE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  321    321   
    ::aws_smithy_schema::ShapeId::from_static(
  322    322   
        "com.amazonaws.route53#KeySigningKey$DigestValue",
  323    323   
        "com.amazonaws.route53",
  324    324   
        "KeySigningKey",
  325    325   
    ),
  326    326   
    ::aws_smithy_schema::ShapeType::String,
  327         -
    "digest_value",
         327  +
    "DigestValue",
  328    328   
    8,
  329    329   
);
  330    330   
static KEYSIGNINGKEY_MEMBER_PUBLIC_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  331    331   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$PublicKey", "com.amazonaws.route53", "KeySigningKey"),
  332    332   
    ::aws_smithy_schema::ShapeType::String,
  333         -
    "public_key",
         333  +
    "PublicKey",
  334    334   
    9,
  335    335   
);
  336    336   
static KEYSIGNINGKEY_MEMBER_DS_RECORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  337    337   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$DSRecord", "com.amazonaws.route53", "KeySigningKey"),
  338    338   
    ::aws_smithy_schema::ShapeType::String,
  339         -
    "ds_record",
         339  +
    "DSRecord",
  340    340   
    10,
  341    341   
);
  342    342   
static KEYSIGNINGKEY_MEMBER_DNSKEY_RECORD: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  343    343   
    ::aws_smithy_schema::ShapeId::from_static(
  344    344   
        "com.amazonaws.route53#KeySigningKey$DNSKEYRecord",
  345    345   
        "com.amazonaws.route53",
  346    346   
        "KeySigningKey",
  347    347   
    ),
  348    348   
    ::aws_smithy_schema::ShapeType::String,
  349         -
    "dnskey_record",
         349  +
    "DNSKEYRecord",
  350    350   
    11,
  351    351   
);
  352    352   
static KEYSIGNINGKEY_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  353    353   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#KeySigningKey$Status", "com.amazonaws.route53", "KeySigningKey"),
  354    354   
    ::aws_smithy_schema::ShapeType::String,
  355         -
    "status",
         355  +
    "Status",
  356    356   
    12,
  357    357   
);
  358    358   
static KEYSIGNINGKEY_MEMBER_STATUS_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  359    359   
    ::aws_smithy_schema::ShapeId::from_static(
  360    360   
        "com.amazonaws.route53#KeySigningKey$StatusMessage",
  361    361   
        "com.amazonaws.route53",
  362    362   
        "KeySigningKey",
  363    363   
    ),
  364    364   
    ::aws_smithy_schema::ShapeType::String,
  365         -
    "status_message",
         365  +
    "StatusMessage",
  366    366   
    13,
  367    367   
);
  368    368   
static KEYSIGNINGKEY_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  369    369   
    ::aws_smithy_schema::ShapeId::from_static(
  370    370   
        "com.amazonaws.route53#KeySigningKey$CreatedDate",
  371    371   
        "com.amazonaws.route53",
  372    372   
        "KeySigningKey",
  373    373   
    ),
  374    374   
    ::aws_smithy_schema::ShapeType::Timestamp,
  375         -
    "created_date",
         375  +
    "CreatedDate",
  376    376   
    14,
  377    377   
);
  378    378   
static KEYSIGNINGKEY_MEMBER_LAST_MODIFIED_DATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  379    379   
    ::aws_smithy_schema::ShapeId::from_static(
  380    380   
        "com.amazonaws.route53#KeySigningKey$LastModifiedDate",
  381    381   
        "com.amazonaws.route53",
  382    382   
        "KeySigningKey",
  383    383   
    ),
  384    384   
    ::aws_smithy_schema::ShapeType::Timestamp,
  385         -
    "last_modified_date",
         385  +
    "LastModifiedDate",
  386    386   
    15,
  387    387   
);
  388    388   
static KEYSIGNINGKEY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  389    389   
    KEYSIGNINGKEY_SCHEMA_ID,
  390    390   
    ::aws_smithy_schema::ShapeType::Structure,
  391    391   
    &[
  392    392   
        &KEYSIGNINGKEY_MEMBER_NAME,
  393    393   
        &KEYSIGNINGKEY_MEMBER_KMS_ARN,
  394    394   
        &KEYSIGNINGKEY_MEMBER_FLAG,
  395    395   
        &KEYSIGNINGKEY_MEMBER_SIGNING_ALGORITHM_MNEMONIC,
@@ -447,447 +575,586 @@
  467    467   
            ser.write_timestamp(&KEYSIGNINGKEY_MEMBER_CREATED_DATE, val)?;
  468    468   
        }
  469    469   
        if let Some(ref val) = self.last_modified_date {
  470    470   
            ser.write_timestamp(&KEYSIGNINGKEY_MEMBER_LAST_MODIFIED_DATE, val)?;
  471    471   
        }
  472    472   
        Ok(())
  473    473   
    }
  474    474   
}
  475    475   
impl KeySigningKey {
  476    476   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  477         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  478         -
        deserializer: &mut D,
         477  +
    pub fn deserialize(
         478  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  479    479   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  480    480   
        #[allow(unused_variables, unused_mut)]
  481    481   
        let mut builder = Self::builder();
  482    482   
        #[allow(
  483    483   
            unused_variables,
  484    484   
            unreachable_code,
  485    485   
            clippy::single_match,
  486    486   
            clippy::match_single_binding,
  487    487   
            clippy::diverging_sub_expression
  488    488   
        )]
  489         -
        deserializer.read_struct(&KEYSIGNINGKEY_SCHEMA, (), |_, member, deser| {
         489  +
        deserializer.read_struct(&KEYSIGNINGKEY_SCHEMA, &mut |member, deser| {
  490    490   
            match member.member_index() {
  491    491   
                Some(0) => {
  492    492   
                    builder.name = Some(deser.read_string(member)?);
  493    493   
                }
  494    494   
                Some(1) => {
  495    495   
                    builder.kms_arn = Some(deser.read_string(member)?);
  496    496   
                }
  497    497   
                Some(2) => {
  498    498   
                    builder.flag = Some(deser.read_integer(member)?);
  499    499   
                }
  500    500   
                Some(3) => {
  501    501   
                    builder.signing_algorithm_mnemonic = Some(deser.read_string(member)?);
  502    502   
                }
  503    503   
                Some(4) => {
  504    504   
                    builder.signing_algorithm_type = Some(deser.read_integer(member)?);
  505    505   
                }
  506    506   
                Some(5) => {
  507    507   
                    builder.digest_algorithm_mnemonic = Some(deser.read_string(member)?);
  508    508   
                }
  509    509   
                Some(6) => {
  510    510   
                    builder.digest_algorithm_type = Some(deser.read_integer(member)?);
  511    511   
                }
  512    512   
                Some(7) => {
  513    513   
                    builder.key_tag = Some(deser.read_integer(member)?);
  514    514   
                }
  515    515   
                Some(8) => {
  516    516   
                    builder.digest_value = Some(deser.read_string(member)?);
  517    517   
                }
  518    518   
                Some(9) => {
  519    519   
                    builder.public_key = Some(deser.read_string(member)?);
  520    520   
                }
  521    521   
                Some(10) => {
  522    522   
                    builder.ds_record = Some(deser.read_string(member)?);
  523    523   
                }
  524    524   
                Some(11) => {
  525    525   
                    builder.dnskey_record = Some(deser.read_string(member)?);
  526    526   
                }
  527    527   
                Some(12) => {
  528    528   
                    builder.status = Some(deser.read_string(member)?);
  529    529   
                }
  530    530   
                Some(13) => {
  531    531   
                    builder.status_message = Some(deser.read_string(member)?);
  532    532   
                }
  533    533   
                Some(14) => {
  534    534   
                    builder.created_date = Some(deser.read_timestamp(member)?);
  535    535   
                }
  536    536   
                Some(15) => {
  537    537   
                    builder.last_modified_date = Some(deser.read_timestamp(member)?);
  538    538   
                }
  539    539   
                _ => {}
  540    540   
            }
  541    541   
            Ok(())
  542    542   
        })?;
  543    543   
        Ok(builder.build())
  544    544   
    }
  545    545   
}
         546  +
impl KeySigningKey {
         547  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         548  +
    pub fn deserialize_with_response(
         549  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         550  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         551  +
        _status: u16,
         552  +
        _body: &[u8],
         553  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         554  +
        Self::deserialize(deserializer)
         555  +
    }
         556  +
}
  546    557   
impl KeySigningKey {
  547    558   
    /// Creates a new builder-style object to manufacture [`KeySigningKey`](crate::types::KeySigningKey).
  548    559   
    pub fn builder() -> crate::types::builders::KeySigningKeyBuilder {
  549    560   
        crate::types::builders::KeySigningKeyBuilder::default()
  550    561   
    }
  551    562   
}
  552    563   
  553    564   
/// A builder for [`KeySigningKey`](crate::types::KeySigningKey).
  554    565   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  555    566   
#[non_exhaustive]

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

@@ -1,1 +126,137 @@
   21     21   
}
   22     22   
static LINKEDSERVICE_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#LinkedService", "com.amazonaws.route53", "LinkedService");
   24     24   
static LINKEDSERVICE_MEMBER_SERVICE_PRINCIPAL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static(
   26     26   
        "com.amazonaws.route53#LinkedService$ServicePrincipal",
   27     27   
        "com.amazonaws.route53",
   28     28   
        "LinkedService",
   29     29   
    ),
   30     30   
    ::aws_smithy_schema::ShapeType::String,
   31         -
    "service_principal",
          31  +
    "ServicePrincipal",
   32     32   
    0,
   33     33   
);
   34     34   
static LINKEDSERVICE_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   35     35   
    ::aws_smithy_schema::ShapeId::from_static(
   36     36   
        "com.amazonaws.route53#LinkedService$Description",
   37     37   
        "com.amazonaws.route53",
   38     38   
        "LinkedService",
   39     39   
    ),
   40     40   
    ::aws_smithy_schema::ShapeType::String,
   41         -
    "description",
          41  +
    "Description",
   42     42   
    1,
   43     43   
);
   44     44   
static LINKEDSERVICE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   45     45   
    LINKEDSERVICE_SCHEMA_ID,
   46     46   
    ::aws_smithy_schema::ShapeType::Structure,
   47     47   
    &[&LINKEDSERVICE_MEMBER_SERVICE_PRINCIPAL, &LINKEDSERVICE_MEMBER_DESCRIPTION],
   48     48   
);
   49     49   
impl LinkedService {
   50     50   
    /// The schema for this shape.
   51     51   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &LINKEDSERVICE_SCHEMA;
   52     52   
}
   53     53   
impl ::aws_smithy_schema::serde::SerializableStruct for LinkedService {
   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.service_principal {
   60     60   
            ser.write_string(&LINKEDSERVICE_MEMBER_SERVICE_PRINCIPAL, val)?;
   61     61   
        }
   62     62   
        if let Some(ref val) = self.description {
   63     63   
            ser.write_string(&LINKEDSERVICE_MEMBER_DESCRIPTION, val)?;
   64     64   
        }
   65     65   
        Ok(())
   66     66   
    }
   67     67   
}
   68     68   
impl LinkedService {
   69     69   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   70         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   71         -
        deserializer: &mut D,
          70  +
    pub fn deserialize(
          71  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   72     72   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   73     73   
        #[allow(unused_variables, unused_mut)]
   74     74   
        let mut builder = Self::builder();
   75     75   
        #[allow(
   76     76   
            unused_variables,
   77     77   
            unreachable_code,
   78     78   
            clippy::single_match,
   79     79   
            clippy::match_single_binding,
   80     80   
            clippy::diverging_sub_expression
   81     81   
        )]
   82         -
        deserializer.read_struct(&LINKEDSERVICE_SCHEMA, (), |_, member, deser| {
          82  +
        deserializer.read_struct(&LINKEDSERVICE_SCHEMA, &mut |member, deser| {
   83     83   
            match member.member_index() {
   84     84   
                Some(0) => {
   85     85   
                    builder.service_principal = Some(deser.read_string(member)?);
   86     86   
                }
   87     87   
                Some(1) => {
   88     88   
                    builder.description = Some(deser.read_string(member)?);
   89     89   
                }
   90     90   
                _ => {}
   91     91   
            }
   92     92   
            Ok(())
   93     93   
        })?;
   94     94   
        Ok(builder.build())
   95     95   
    }
   96     96   
}
          97  +
impl LinkedService {
          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  +
}
   97    108   
impl LinkedService {
   98    109   
    /// Creates a new builder-style object to manufacture [`LinkedService`](crate::types::LinkedService).
   99    110   
    pub fn builder() -> crate::types::builders::LinkedServiceBuilder {
  100    111   
        crate::types::builders::LinkedServiceBuilder::default()
  101    112   
    }
  102    113   
}
  103    114   
  104    115   
/// A builder for [`LinkedService`](crate::types::LinkedService).
  105    116   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  106    117   
#[non_exhaustive]

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

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

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

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

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

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

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

@@ -464,464 +664,664 @@
  484    484   
}
  485    485   
static RESOURCERECORDSET_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
  486    486   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#ResourceRecordSet", "com.amazonaws.route53", "ResourceRecordSet");
  487    487   
static RESOURCERECORDSET_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  488    488   
    ::aws_smithy_schema::ShapeId::from_static(
  489    489   
        "com.amazonaws.route53#ResourceRecordSet$Name",
  490    490   
        "com.amazonaws.route53",
  491    491   
        "ResourceRecordSet",
  492    492   
    ),
  493    493   
    ::aws_smithy_schema::ShapeType::String,
  494         -
    "name",
         494  +
    "Name",
  495    495   
    0,
  496    496   
);
  497    497   
static RESOURCERECORDSET_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  498    498   
    ::aws_smithy_schema::ShapeId::from_static(
  499    499   
        "com.amazonaws.route53#ResourceRecordSet$Type",
  500    500   
        "com.amazonaws.route53",
  501    501   
        "ResourceRecordSet",
  502    502   
    ),
  503    503   
    ::aws_smithy_schema::ShapeType::String,
  504         -
    "r##type",
         504  +
    "Type",
  505    505   
    1,
  506    506   
);
  507    507   
static RESOURCERECORDSET_MEMBER_SET_IDENTIFIER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  508    508   
    ::aws_smithy_schema::ShapeId::from_static(
  509    509   
        "com.amazonaws.route53#ResourceRecordSet$SetIdentifier",
  510    510   
        "com.amazonaws.route53",
  511    511   
        "ResourceRecordSet",
  512    512   
    ),
  513    513   
    ::aws_smithy_schema::ShapeType::String,
  514         -
    "set_identifier",
         514  +
    "SetIdentifier",
  515    515   
    2,
  516    516   
);
  517    517   
static RESOURCERECORDSET_MEMBER_WEIGHT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  518    518   
    ::aws_smithy_schema::ShapeId::from_static(
  519    519   
        "com.amazonaws.route53#ResourceRecordSet$Weight",
  520    520   
        "com.amazonaws.route53",
  521    521   
        "ResourceRecordSet",
  522    522   
    ),
  523    523   
    ::aws_smithy_schema::ShapeType::Long,
  524         -
    "weight",
         524  +
    "Weight",
  525    525   
    3,
  526    526   
);
  527    527   
static RESOURCERECORDSET_MEMBER_REGION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  528    528   
    ::aws_smithy_schema::ShapeId::from_static(
  529    529   
        "com.amazonaws.route53#ResourceRecordSet$Region",
  530    530   
        "com.amazonaws.route53",
  531    531   
        "ResourceRecordSet",
  532    532   
    ),
  533    533   
    ::aws_smithy_schema::ShapeType::String,
  534         -
    "region",
         534  +
    "Region",
  535    535   
    4,
  536    536   
);
  537    537   
static RESOURCERECORDSET_MEMBER_GEO_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  538    538   
    ::aws_smithy_schema::ShapeId::from_static(
  539    539   
        "com.amazonaws.route53#ResourceRecordSet$GeoLocation",
  540    540   
        "com.amazonaws.route53",
  541    541   
        "ResourceRecordSet",
  542    542   
    ),
  543    543   
    ::aws_smithy_schema::ShapeType::Structure,
  544         -
    "geo_location",
         544  +
    "GeoLocation",
  545    545   
    5,
  546    546   
);
  547    547   
static RESOURCERECORDSET_MEMBER_FAILOVER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  548    548   
    ::aws_smithy_schema::ShapeId::from_static(
  549    549   
        "com.amazonaws.route53#ResourceRecordSet$Failover",
  550    550   
        "com.amazonaws.route53",
  551    551   
        "ResourceRecordSet",
  552    552   
    ),
  553    553   
    ::aws_smithy_schema::ShapeType::String,
  554         -
    "failover",
         554  +
    "Failover",
  555    555   
    6,
  556    556   
);
  557    557   
static RESOURCERECORDSET_MEMBER_MULTI_VALUE_ANSWER: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  558    558   
    ::aws_smithy_schema::ShapeId::from_static(
  559    559   
        "com.amazonaws.route53#ResourceRecordSet$MultiValueAnswer",
  560    560   
        "com.amazonaws.route53",
  561    561   
        "ResourceRecordSet",
  562    562   
    ),
  563    563   
    ::aws_smithy_schema::ShapeType::Boolean,
  564         -
    "multi_value_answer",
         564  +
    "MultiValueAnswer",
  565    565   
    7,
  566    566   
);
  567    567   
static RESOURCERECORDSET_MEMBER_TTL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  568    568   
    ::aws_smithy_schema::ShapeId::from_static(
  569    569   
        "com.amazonaws.route53#ResourceRecordSet$TTL",
  570    570   
        "com.amazonaws.route53",
  571    571   
        "ResourceRecordSet",
  572    572   
    ),
  573    573   
    ::aws_smithy_schema::ShapeType::Long,
  574         -
    "ttl",
         574  +
    "TTL",
  575    575   
    8,
  576    576   
);
  577    577   
static RESOURCERECORDSET_MEMBER_RESOURCE_RECORDS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  578    578   
    ::aws_smithy_schema::ShapeId::from_static(
  579    579   
        "com.amazonaws.route53#ResourceRecordSet$ResourceRecords",
  580    580   
        "com.amazonaws.route53",
  581    581   
        "ResourceRecordSet",
  582    582   
    ),
  583    583   
    ::aws_smithy_schema::ShapeType::List,
  584         -
    "resource_records",
         584  +
    "ResourceRecords",
  585    585   
    9,
  586    586   
);
  587    587   
static RESOURCERECORDSET_MEMBER_ALIAS_TARGET: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  588    588   
    ::aws_smithy_schema::ShapeId::from_static(
  589    589   
        "com.amazonaws.route53#ResourceRecordSet$AliasTarget",
  590    590   
        "com.amazonaws.route53",
  591    591   
        "ResourceRecordSet",
  592    592   
    ),
  593    593   
    ::aws_smithy_schema::ShapeType::Structure,
  594         -
    "alias_target",
         594  +
    "AliasTarget",
  595    595   
    10,
  596    596   
);
  597    597   
static RESOURCERECORDSET_MEMBER_HEALTH_CHECK_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  598    598   
    ::aws_smithy_schema::ShapeId::from_static(
  599    599   
        "com.amazonaws.route53#ResourceRecordSet$HealthCheckId",
  600    600   
        "com.amazonaws.route53",
  601    601   
        "ResourceRecordSet",
  602    602   
    ),
  603    603   
    ::aws_smithy_schema::ShapeType::String,
  604         -
    "health_check_id",
         604  +
    "HealthCheckId",
  605    605   
    11,
  606    606   
);
  607    607   
static RESOURCERECORDSET_MEMBER_TRAFFIC_POLICY_INSTANCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  608    608   
    ::aws_smithy_schema::ShapeId::from_static(
  609    609   
        "com.amazonaws.route53#ResourceRecordSet$TrafficPolicyInstanceId",
  610    610   
        "com.amazonaws.route53",
  611    611   
        "ResourceRecordSet",
  612    612   
    ),
  613    613   
    ::aws_smithy_schema::ShapeType::String,
  614         -
    "traffic_policy_instance_id",
         614  +
    "TrafficPolicyInstanceId",
  615    615   
    12,
  616    616   
);
  617    617   
static RESOURCERECORDSET_MEMBER_CIDR_ROUTING_CONFIG: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  618    618   
    ::aws_smithy_schema::ShapeId::from_static(
  619    619   
        "com.amazonaws.route53#ResourceRecordSet$CidrRoutingConfig",
  620    620   
        "com.amazonaws.route53",
  621    621   
        "ResourceRecordSet",
  622    622   
    ),
  623    623   
    ::aws_smithy_schema::ShapeType::Structure,
  624         -
    "cidr_routing_config",
         624  +
    "CidrRoutingConfig",
  625    625   
    13,
  626    626   
);
  627    627   
static RESOURCERECORDSET_MEMBER_GEO_PROXIMITY_LOCATION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  628    628   
    ::aws_smithy_schema::ShapeId::from_static(
  629    629   
        "com.amazonaws.route53#ResourceRecordSet$GeoProximityLocation",
  630    630   
        "com.amazonaws.route53",
  631    631   
        "ResourceRecordSet",
  632    632   
    ),
  633    633   
    ::aws_smithy_schema::ShapeType::Structure,
  634         -
    "geo_proximity_location",
         634  +
    "GeoProximityLocation",
  635    635   
    14,
  636    636   
);
  637    637   
static RESOURCERECORDSET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  638    638   
    RESOURCERECORDSET_SCHEMA_ID,
  639    639   
    ::aws_smithy_schema::ShapeType::Structure,
  640    640   
    &[
  641    641   
        &RESOURCERECORDSET_MEMBER_NAME,
  642    642   
        &RESOURCERECORDSET_MEMBER_TYPE,
  643    643   
        &RESOURCERECORDSET_MEMBER_SET_IDENTIFIER,
  644    644   
        &RESOURCERECORDSET_MEMBER_WEIGHT,
@@ -698,698 +835,844 @@
  718    718   
            ser.write_struct(&RESOURCERECORDSET_MEMBER_CIDR_ROUTING_CONFIG, val)?;
  719    719   
        }
  720    720   
        if let Some(ref val) = self.geo_proximity_location {
  721    721   
            ser.write_struct(&RESOURCERECORDSET_MEMBER_GEO_PROXIMITY_LOCATION, val)?;
  722    722   
        }
  723    723   
        Ok(())
  724    724   
    }
  725    725   
}
  726    726   
impl ResourceRecordSet {
  727    727   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  728         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  729         -
        deserializer: &mut D,
         728  +
    pub fn deserialize(
         729  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  730    730   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  731    731   
        #[allow(unused_variables, unused_mut)]
  732    732   
        let mut builder = Self::builder();
  733    733   
        #[allow(
  734    734   
            unused_variables,
  735    735   
            unreachable_code,
  736    736   
            clippy::single_match,
  737    737   
            clippy::match_single_binding,
  738    738   
            clippy::diverging_sub_expression
  739    739   
        )]
  740         -
        deserializer.read_struct(&RESOURCERECORDSET_SCHEMA, (), |_, member, deser| {
         740  +
        deserializer.read_struct(&RESOURCERECORDSET_SCHEMA, &mut |member, deser| {
  741    741   
            match member.member_index() {
  742    742   
                Some(0) => {
  743    743   
                    builder.name = Some(deser.read_string(member)?);
  744    744   
                }
  745    745   
                Some(1) => {
  746    746   
                    builder.r#type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
  747    747   
                }
  748    748   
                Some(2) => {
  749    749   
                    builder.set_identifier = Some(deser.read_string(member)?);
  750    750   
                }
  751    751   
                Some(3) => {
  752    752   
                    builder.weight = Some(deser.read_long(member)?);
  753    753   
                }
  754    754   
                Some(4) => {
  755    755   
                    builder.region = Some(crate::types::ResourceRecordSetRegion::from(deser.read_string(member)?.as_str()));
  756    756   
                }
  757    757   
                Some(5) => {
  758    758   
                    builder.geo_location = Some(crate::types::GeoLocation::deserialize(deser)?);
  759    759   
                }
  760    760   
                Some(6) => {
  761    761   
                    builder.failover = Some(crate::types::ResourceRecordSetFailover::from(deser.read_string(member)?.as_str()));
  762    762   
                }
  763    763   
                Some(7) => {
  764    764   
                    builder.multi_value_answer = Some(deser.read_boolean(member)?);
  765    765   
                }
  766    766   
                Some(8) => {
  767    767   
                    builder.ttl = Some(deser.read_long(member)?);
  768    768   
                }
  769    769   
                Some(9) => {
  770    770   
                    builder.resource_records = Some({
  771         -
                        let container = if let Some(cap) = deser.container_size() {
  772         -
                            Vec::with_capacity(cap)
  773         -
                        } else {
  774         -
                            Vec::new()
  775         -
                        };
  776         -
                        deser.read_list(member, container, |mut list, deser| {
  777         -
                            list.push(crate::types::ResourceRecord::deserialize(deser)?);
  778         -
                            Ok(list)
  779         -
                        })?
         771  +
                        let mut container = Vec::new();
         772  +
                        deser.read_list(member, &mut |deser| {
         773  +
                            container.push(crate::types::ResourceRecord::deserialize(deser)?);
         774  +
                            Ok(())
         775  +
                        })?;
         776  +
                        container
  780    777   
                    });
  781    778   
                }
  782    779   
                Some(10) => {
  783    780   
                    builder.alias_target = Some(crate::types::AliasTarget::deserialize(deser)?);
  784    781   
                }
  785    782   
                Some(11) => {
  786    783   
                    builder.health_check_id = Some(deser.read_string(member)?);
  787    784   
                }
  788    785   
                Some(12) => {
  789    786   
                    builder.traffic_policy_instance_id = Some(deser.read_string(member)?);
  790    787   
                }
  791    788   
                Some(13) => {
  792    789   
                    builder.cidr_routing_config = Some(crate::types::CidrRoutingConfig::deserialize(deser)?);
  793    790   
                }
  794    791   
                Some(14) => {
  795    792   
                    builder.geo_proximity_location = Some(crate::types::GeoProximityLocation::deserialize(deser)?);
  796    793   
                }
  797    794   
                _ => {}
  798    795   
            }
  799    796   
            Ok(())
  800    797   
        })?;
         798  +
        builder.name = builder.name.or(Some(String::new()));
  801    799   
        builder
  802    800   
            .build()
  803    801   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  804    802   
    }
  805    803   
}
         804  +
impl ResourceRecordSet {
         805  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         806  +
    pub fn deserialize_with_response(
         807  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         808  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         809  +
        _status: u16,
         810  +
        _body: &[u8],
         811  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         812  +
        Self::deserialize(deserializer)
         813  +
    }
         814  +
}
  806    815   
impl ResourceRecordSet {
  807    816   
    /// Creates a new builder-style object to manufacture [`ResourceRecordSet`](crate::types::ResourceRecordSet).
  808    817   
    pub fn builder() -> crate::types::builders::ResourceRecordSetBuilder {
  809    818   
        crate::types::builders::ResourceRecordSetBuilder::default()
  810    819   
    }
  811    820   
}
  812    821   
  813    822   
/// A builder for [`ResourceRecordSet`](crate::types::ResourceRecordSet).
  814    823   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  815    824   
#[non_exhaustive]