AWS SDK

AWS SDK

rev. 96f5a1b4ad139d2f1ad1e8e40f300e1cd1ff574c

Files changed:

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]

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

@@ -21,21 +180,188 @@
   41     41   
}
   42     42   
static RESOURCETAGSET_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   43     43   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#ResourceTagSet", "com.amazonaws.route53", "ResourceTagSet");
   44     44   
static RESOURCETAGSET_MEMBER_RESOURCE_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   45     45   
    ::aws_smithy_schema::ShapeId::from_static(
   46     46   
        "com.amazonaws.route53#ResourceTagSet$ResourceType",
   47     47   
        "com.amazonaws.route53",
   48     48   
        "ResourceTagSet",
   49     49   
    ),
   50     50   
    ::aws_smithy_schema::ShapeType::String,
   51         -
    "resource_type",
          51  +
    "ResourceType",
   52     52   
    0,
   53     53   
);
   54     54   
static RESOURCETAGSET_MEMBER_RESOURCE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   55     55   
    ::aws_smithy_schema::ShapeId::from_static(
   56     56   
        "com.amazonaws.route53#ResourceTagSet$ResourceId",
   57     57   
        "com.amazonaws.route53",
   58     58   
        "ResourceTagSet",
   59     59   
    ),
   60     60   
    ::aws_smithy_schema::ShapeType::String,
   61         -
    "resource_id",
          61  +
    "ResourceId",
   62     62   
    1,
   63     63   
);
   64     64   
static RESOURCETAGSET_MEMBER_TAGS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   65     65   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#ResourceTagSet$Tags", "com.amazonaws.route53", "ResourceTagSet"),
   66     66   
    ::aws_smithy_schema::ShapeType::List,
   67         -
    "tags",
          67  +
    "Tags",
   68     68   
    2,
   69     69   
);
   70     70   
static RESOURCETAGSET_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   71     71   
    RESOURCETAGSET_SCHEMA_ID,
   72     72   
    ::aws_smithy_schema::ShapeType::Structure,
   73     73   
    &[
   74     74   
        &RESOURCETAGSET_MEMBER_RESOURCE_TYPE,
   75     75   
        &RESOURCETAGSET_MEMBER_RESOURCE_ID,
   76     76   
        &RESOURCETAGSET_MEMBER_TAGS,
   77     77   
    ],
   78     78   
);
   79     79   
impl ResourceTagSet {
   80     80   
    /// The schema for this shape.
   81     81   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &RESOURCETAGSET_SCHEMA;
   82     82   
}
   83     83   
impl ::aws_smithy_schema::serde::SerializableStruct for ResourceTagSet {
   84     84   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   85     85   
    fn serialize_members(
   86     86   
        &self,
   87     87   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   88     88   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   89     89   
        if let Some(ref val) = self.resource_type {
   90     90   
            ser.write_string(&RESOURCETAGSET_MEMBER_RESOURCE_TYPE, val.as_str())?;
   91     91   
        }
   92     92   
        if let Some(ref val) = self.resource_id {
   93     93   
            ser.write_string(&RESOURCETAGSET_MEMBER_RESOURCE_ID, val)?;
   94     94   
        }
   95     95   
        if let Some(ref val) = self.tags {
   96     96   
            ser.write_list(
   97     97   
                &RESOURCETAGSET_MEMBER_TAGS,
   98     98   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
   99     99   
                    for item in val {
  100    100   
                        ser.write_struct(crate::types::Tag::SCHEMA, item)?;
  101    101   
                    }
  102    102   
                    Ok(())
  103    103   
                },
  104    104   
            )?;
  105    105   
        }
  106    106   
        Ok(())
  107    107   
    }
  108    108   
}
  109    109   
impl ResourceTagSet {
  110    110   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  111         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  112         -
        deserializer: &mut D,
         111  +
    pub fn deserialize(
         112  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  113    113   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  114    114   
        #[allow(unused_variables, unused_mut)]
  115    115   
        let mut builder = Self::builder();
  116    116   
        #[allow(
  117    117   
            unused_variables,
  118    118   
            unreachable_code,
  119    119   
            clippy::single_match,
  120    120   
            clippy::match_single_binding,
  121    121   
            clippy::diverging_sub_expression
  122    122   
        )]
  123         -
        deserializer.read_struct(&RESOURCETAGSET_SCHEMA, (), |_, member, deser| {
         123  +
        deserializer.read_struct(&RESOURCETAGSET_SCHEMA, &mut |member, deser| {
  124    124   
            match member.member_index() {
  125    125   
                Some(0) => {
  126    126   
                    builder.resource_type = Some(crate::types::TagResourceType::from(deser.read_string(member)?.as_str()));
  127    127   
                }
  128    128   
                Some(1) => {
  129    129   
                    builder.resource_id = Some(deser.read_string(member)?);
  130    130   
                }
  131    131   
                Some(2) => {
  132    132   
                    builder.tags = Some({
  133         -
                        let container = if let Some(cap) = deser.container_size() {
  134         -
                            Vec::with_capacity(cap)
  135         -
                        } else {
  136         -
                            Vec::new()
  137         -
                        };
  138         -
                        deser.read_list(member, container, |mut list, deser| {
  139         -
                            list.push(crate::types::Tag::deserialize(deser)?);
  140         -
                            Ok(list)
  141         -
                        })?
         133  +
                        let mut container = Vec::new();
         134  +
                        deser.read_list(member, &mut |deser| {
         135  +
                            container.push(crate::types::Tag::deserialize(deser)?);
         136  +
                            Ok(())
         137  +
                        })?;
         138  +
                        container
  142    139   
                    });
  143    140   
                }
  144    141   
                _ => {}
  145    142   
            }
  146    143   
            Ok(())
  147    144   
        })?;
  148    145   
        Ok(builder.build())
  149    146   
    }
  150    147   
}
         148  +
impl ResourceTagSet {
         149  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         150  +
    pub fn deserialize_with_response(
         151  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         152  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         153  +
        _status: u16,
         154  +
        _body: &[u8],
         155  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         156  +
        Self::deserialize(deserializer)
         157  +
    }
         158  +
}
  151    159   
impl ResourceTagSet {
  152    160   
    /// Creates a new builder-style object to manufacture [`ResourceTagSet`](crate::types::ResourceTagSet).
  153    161   
    pub fn builder() -> crate::types::builders::ResourceTagSetBuilder {
  154    162   
        crate::types::builders::ResourceTagSetBuilder::default()
  155    163   
    }
  156    164   
}
  157    165   
  158    166   
/// A builder for [`ResourceTagSet`](crate::types::ResourceTagSet).
  159    167   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  160    168   
#[non_exhaustive]

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

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

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

@@ -1,1 +118,129 @@
   17     17   
    /// <p>The date and time that the health checker performed the health check in <a href="https://en.wikipedia.org/wiki/ISO_8601">ISO 8601 format</a> and Coordinated Universal Time (UTC). For example, the value <code>2017-03-27T17:48:16.751Z</code> represents March 27, 2017 at 17:48:16.751 UTC.</p>
   18     18   
    pub fn checked_time(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
   19     19   
        self.checked_time.as_ref()
   20     20   
    }
   21     21   
}
   22     22   
static STATUSREPORT_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   23     23   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#StatusReport", "com.amazonaws.route53", "StatusReport");
   24     24   
static STATUSREPORT_MEMBER_STATUS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   25     25   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#StatusReport$Status", "com.amazonaws.route53", "StatusReport"),
   26     26   
    ::aws_smithy_schema::ShapeType::String,
   27         -
    "status",
          27  +
    "Status",
   28     28   
    0,
   29     29   
);
   30     30   
static STATUSREPORT_MEMBER_CHECKED_TIME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   31     31   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#StatusReport$CheckedTime", "com.amazonaws.route53", "StatusReport"),
   32     32   
    ::aws_smithy_schema::ShapeType::Timestamp,
   33         -
    "checked_time",
          33  +
    "CheckedTime",
   34     34   
    1,
   35     35   
);
   36     36   
static STATUSREPORT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   37     37   
    STATUSREPORT_SCHEMA_ID,
   38     38   
    ::aws_smithy_schema::ShapeType::Structure,
   39     39   
    &[&STATUSREPORT_MEMBER_STATUS, &STATUSREPORT_MEMBER_CHECKED_TIME],
   40     40   
);
   41     41   
impl StatusReport {
   42     42   
    /// The schema for this shape.
   43     43   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &STATUSREPORT_SCHEMA;
   44     44   
}
   45     45   
impl ::aws_smithy_schema::serde::SerializableStruct for StatusReport {
   46     46   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
   47     47   
    fn serialize_members(
   48     48   
        &self,
   49     49   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
   50     50   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
   51     51   
        if let Some(ref val) = self.status {
   52     52   
            ser.write_string(&STATUSREPORT_MEMBER_STATUS, val)?;
   53     53   
        }
   54     54   
        if let Some(ref val) = self.checked_time {
   55     55   
            ser.write_timestamp(&STATUSREPORT_MEMBER_CHECKED_TIME, val)?;
   56     56   
        }
   57     57   
        Ok(())
   58     58   
    }
   59     59   
}
   60     60   
impl StatusReport {
   61     61   
    /// Deserializes this structure from a [`ShapeDeserializer`].
   62         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
   63         -
        deserializer: &mut D,
          62  +
    pub fn deserialize(
          63  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
   64     64   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
   65     65   
        #[allow(unused_variables, unused_mut)]
   66     66   
        let mut builder = Self::builder();
   67     67   
        #[allow(
   68     68   
            unused_variables,
   69     69   
            unreachable_code,
   70     70   
            clippy::single_match,
   71     71   
            clippy::match_single_binding,
   72     72   
            clippy::diverging_sub_expression
   73     73   
        )]
   74         -
        deserializer.read_struct(&STATUSREPORT_SCHEMA, (), |_, member, deser| {
          74  +
        deserializer.read_struct(&STATUSREPORT_SCHEMA, &mut |member, deser| {
   75     75   
            match member.member_index() {
   76     76   
                Some(0) => {
   77     77   
                    builder.status = Some(deser.read_string(member)?);
   78     78   
                }
   79     79   
                Some(1) => {
   80     80   
                    builder.checked_time = Some(deser.read_timestamp(member)?);
   81     81   
                }
   82     82   
                _ => {}
   83     83   
            }
   84     84   
            Ok(())
   85     85   
        })?;
   86     86   
        Ok(builder.build())
   87     87   
    }
   88     88   
}
          89  +
impl StatusReport {
          90  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          91  +
    pub fn deserialize_with_response(
          92  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          93  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          94  +
        _status: u16,
          95  +
        _body: &[u8],
          96  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          97  +
        Self::deserialize(deserializer)
          98  +
    }
          99  +
}
   89    100   
impl StatusReport {
   90    101   
    /// Creates a new builder-style object to manufacture [`StatusReport`](crate::types::StatusReport).
   91    102   
    pub fn builder() -> crate::types::builders::StatusReportBuilder {
   92    103   
        crate::types::builders::StatusReportBuilder::default()
   93    104   
    }
   94    105   
}
   95    106   
   96    107   
/// A builder for [`StatusReport`](crate::types::StatusReport).
   97    108   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
   98    109   
#[non_exhaustive]

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

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

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

@@ -24,24 +207,222 @@
   44     44   
    /// <p>The comment that you specify in the <code>CreateTrafficPolicy</code> request, if any.</p>
   45     45   
    pub fn comment(&self) -> ::std::option::Option<&str> {
   46     46   
        self.comment.as_deref()
   47     47   
    }
   48     48   
}
   49     49   
static TRAFFICPOLICY_SCHEMA_ID: ::aws_smithy_schema::ShapeId =
   50     50   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy", "com.amazonaws.route53", "TrafficPolicy");
   51     51   
static TRAFFICPOLICY_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   52     52   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Id", "com.amazonaws.route53", "TrafficPolicy"),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "id",
          54  +
    "Id",
   55     55   
    0,
   56     56   
);
   57     57   
static TRAFFICPOLICY_MEMBER_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Version", "com.amazonaws.route53", "TrafficPolicy"),
   59     59   
    ::aws_smithy_schema::ShapeType::Integer,
   60         -
    "version",
          60  +
    "Version",
   61     61   
    1,
   62     62   
);
   63     63   
static TRAFFICPOLICY_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   64     64   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Name", "com.amazonaws.route53", "TrafficPolicy"),
   65     65   
    ::aws_smithy_schema::ShapeType::String,
   66         -
    "name",
          66  +
    "Name",
   67     67   
    2,
   68     68   
);
   69     69   
static TRAFFICPOLICY_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   70     70   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Type", "com.amazonaws.route53", "TrafficPolicy"),
   71     71   
    ::aws_smithy_schema::ShapeType::String,
   72         -
    "r##type",
          72  +
    "Type",
   73     73   
    3,
   74     74   
);
   75     75   
static TRAFFICPOLICY_MEMBER_DOCUMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Document", "com.amazonaws.route53", "TrafficPolicy"),
   77     77   
    ::aws_smithy_schema::ShapeType::String,
   78         -
    "document",
          78  +
    "Document",
   79     79   
    4,
   80     80   
);
   81     81   
static TRAFFICPOLICY_MEMBER_COMMENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static("com.amazonaws.route53#TrafficPolicy$Comment", "com.amazonaws.route53", "TrafficPolicy"),
   83     83   
    ::aws_smithy_schema::ShapeType::String,
   84         -
    "comment",
          84  +
    "Comment",
   85     85   
    5,
   86     86   
);
   87     87   
static TRAFFICPOLICY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   88     88   
    TRAFFICPOLICY_SCHEMA_ID,
   89     89   
    ::aws_smithy_schema::ShapeType::Structure,
   90     90   
    &[
   91     91   
        &TRAFFICPOLICY_MEMBER_ID,
   92     92   
        &TRAFFICPOLICY_MEMBER_VERSION,
   93     93   
        &TRAFFICPOLICY_MEMBER_NAME,
   94     94   
        &TRAFFICPOLICY_MEMBER_TYPE,
   95     95   
        &TRAFFICPOLICY_MEMBER_DOCUMENT,
   96     96   
        &TRAFFICPOLICY_MEMBER_COMMENT,
   97     97   
    ],
   98     98   
);
   99     99   
impl TrafficPolicy {
  100    100   
    /// The schema for this shape.
  101    101   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRAFFICPOLICY_SCHEMA;
  102    102   
}
  103    103   
impl ::aws_smithy_schema::serde::SerializableStruct for TrafficPolicy {
  104    104   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  105    105   
    fn serialize_members(
  106    106   
        &self,
  107    107   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  108    108   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  109    109   
        {
  110    110   
            let val = &self.id;
  111    111   
            ser.write_string(&TRAFFICPOLICY_MEMBER_ID, val)?;
  112    112   
        }
  113    113   
        {
  114    114   
            let val = &self.version;
  115    115   
            ser.write_integer(&TRAFFICPOLICY_MEMBER_VERSION, *val)?;
  116    116   
        }
  117    117   
        {
  118    118   
            let val = &self.name;
  119    119   
            ser.write_string(&TRAFFICPOLICY_MEMBER_NAME, val)?;
  120    120   
        }
  121    121   
        {
  122    122   
            let val = &self.r#type;
  123    123   
            ser.write_string(&TRAFFICPOLICY_MEMBER_TYPE, val.as_str())?;
  124    124   
        }
  125    125   
        {
  126    126   
            let val = &self.document;
  127    127   
            ser.write_string(&TRAFFICPOLICY_MEMBER_DOCUMENT, val)?;
  128    128   
        }
  129    129   
        if let Some(ref val) = self.comment {
  130    130   
            ser.write_string(&TRAFFICPOLICY_MEMBER_COMMENT, val)?;
  131    131   
        }
  132    132   
        Ok(())
  133    133   
    }
  134    134   
}
  135    135   
impl TrafficPolicy {
  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(&TRAFFICPOLICY_SCHEMA, (), |_, member, deser| {
         149  +
        deserializer.read_struct(&TRAFFICPOLICY_SCHEMA, &mut |member, deser| {
  150    150   
            match member.member_index() {
  151    151   
                Some(0) => {
  152    152   
                    builder.id = Some(deser.read_string(member)?);
  153    153   
                }
  154    154   
                Some(1) => {
  155    155   
                    builder.version = Some(deser.read_integer(member)?);
  156    156   
                }
  157    157   
                Some(2) => {
  158    158   
                    builder.name = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(3) => {
  161    161   
                    builder.r#type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
  162    162   
                }
  163    163   
                Some(4) => {
  164    164   
                    builder.document = Some(deser.read_string(member)?);
  165    165   
                }
  166    166   
                Some(5) => {
  167    167   
                    builder.comment = Some(deser.read_string(member)?);
  168    168   
                }
  169    169   
                _ => {}
  170    170   
            }
  171    171   
            Ok(())
  172    172   
        })?;
         173  +
        builder.id = builder.id.or(Some(String::new()));
         174  +
        builder.version = builder.version.or(Some(0i32));
         175  +
        builder.name = builder.name.or(Some(String::new()));
         176  +
        builder.document = builder.document.or(Some(String::new()));
  173    177   
        builder
  174    178   
            .build()
  175    179   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  176    180   
    }
  177    181   
}
         182  +
impl TrafficPolicy {
         183  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         184  +
    pub fn deserialize_with_response(
         185  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         186  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         187  +
        _status: u16,
         188  +
        _body: &[u8],
         189  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         190  +
        Self::deserialize(deserializer)
         191  +
    }
         192  +
}
  178    193   
impl TrafficPolicy {
  179    194   
    /// Creates a new builder-style object to manufacture [`TrafficPolicy`](crate::types::TrafficPolicy).
  180    195   
    pub fn builder() -> crate::types::builders::TrafficPolicyBuilder {
  181    196   
        crate::types::builders::TrafficPolicyBuilder::default()
  182    197   
    }
  183    198   
}
  184    199   
  185    200   
/// A builder for [`TrafficPolicy`](crate::types::TrafficPolicy).
  186    201   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  187    202   
#[non_exhaustive]

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

@@ -92,92 +232,232 @@
  112    112   
    "com.amazonaws.route53",
  113    113   
    "TrafficPolicyInstance",
  114    114   
);
  115    115   
static TRAFFICPOLICYINSTANCE_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.route53#TrafficPolicyInstance$Id",
  118    118   
        "com.amazonaws.route53",
  119    119   
        "TrafficPolicyInstance",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "id",
         122  +
    "Id",
  123    123   
    0,
  124    124   
);
  125    125   
static TRAFFICPOLICYINSTANCE_MEMBER_HOSTED_ZONE_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.route53#TrafficPolicyInstance$HostedZoneId",
  128    128   
        "com.amazonaws.route53",
  129    129   
        "TrafficPolicyInstance",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::String,
  132         -
    "hosted_zone_id",
         132  +
    "HostedZoneId",
  133    133   
    1,
  134    134   
);
  135    135   
static TRAFFICPOLICYINSTANCE_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.route53#TrafficPolicyInstance$Name",
  138    138   
        "com.amazonaws.route53",
  139    139   
        "TrafficPolicyInstance",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "name",
         142  +
    "Name",
  143    143   
    2,
  144    144   
);
  145    145   
static TRAFFICPOLICYINSTANCE_MEMBER_TTL: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  146    146   
    ::aws_smithy_schema::ShapeId::from_static(
  147    147   
        "com.amazonaws.route53#TrafficPolicyInstance$TTL",
  148    148   
        "com.amazonaws.route53",
  149    149   
        "TrafficPolicyInstance",
  150    150   
    ),
  151    151   
    ::aws_smithy_schema::ShapeType::Long,
  152         -
    "ttl",
         152  +
    "TTL",
  153    153   
    3,
  154    154   
);
  155    155   
static TRAFFICPOLICYINSTANCE_MEMBER_STATE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  156    156   
    ::aws_smithy_schema::ShapeId::from_static(
  157    157   
        "com.amazonaws.route53#TrafficPolicyInstance$State",
  158    158   
        "com.amazonaws.route53",
  159    159   
        "TrafficPolicyInstance",
  160    160   
    ),
  161    161   
    ::aws_smithy_schema::ShapeType::String,
  162         -
    "state",
         162  +
    "State",
  163    163   
    4,
  164    164   
);
  165    165   
static TRAFFICPOLICYINSTANCE_MEMBER_MESSAGE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  166    166   
    ::aws_smithy_schema::ShapeId::from_static(
  167    167   
        "com.amazonaws.route53#TrafficPolicyInstance$Message",
  168    168   
        "com.amazonaws.route53",
  169    169   
        "TrafficPolicyInstance",
  170    170   
    ),
  171    171   
    ::aws_smithy_schema::ShapeType::String,
  172         -
    "message",
         172  +
    "Message",
  173    173   
    5,
  174    174   
);
  175    175   
static TRAFFICPOLICYINSTANCE_MEMBER_TRAFFIC_POLICY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  176    176   
    ::aws_smithy_schema::ShapeId::from_static(
  177    177   
        "com.amazonaws.route53#TrafficPolicyInstance$TrafficPolicyId",
  178    178   
        "com.amazonaws.route53",
  179    179   
        "TrafficPolicyInstance",
  180    180   
    ),
  181    181   
    ::aws_smithy_schema::ShapeType::String,
  182         -
    "traffic_policy_id",
         182  +
    "TrafficPolicyId",
  183    183   
    6,
  184    184   
);
  185    185   
static TRAFFICPOLICYINSTANCE_MEMBER_TRAFFIC_POLICY_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  186    186   
    ::aws_smithy_schema::ShapeId::from_static(
  187    187   
        "com.amazonaws.route53#TrafficPolicyInstance$TrafficPolicyVersion",
  188    188   
        "com.amazonaws.route53",
  189    189   
        "TrafficPolicyInstance",
  190    190   
    ),
  191    191   
    ::aws_smithy_schema::ShapeType::Integer,
  192         -
    "traffic_policy_version",
         192  +
    "TrafficPolicyVersion",
  193    193   
    7,
  194    194   
);
  195    195   
static TRAFFICPOLICYINSTANCE_MEMBER_TRAFFIC_POLICY_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  196    196   
    ::aws_smithy_schema::ShapeId::from_static(
  197    197   
        "com.amazonaws.route53#TrafficPolicyInstance$TrafficPolicyType",
  198    198   
        "com.amazonaws.route53",
  199    199   
        "TrafficPolicyInstance",
  200    200   
    ),
  201    201   
    ::aws_smithy_schema::ShapeType::String,
  202         -
    "traffic_policy_type",
         202  +
    "TrafficPolicyType",
  203    203   
    8,
  204    204   
);
  205    205   
static TRAFFICPOLICYINSTANCE_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  206    206   
    TRAFFICPOLICYINSTANCE_SCHEMA_ID,
  207    207   
    ::aws_smithy_schema::ShapeType::Structure,
  208    208   
    &[
  209    209   
        &TRAFFICPOLICYINSTANCE_MEMBER_ID,
  210    210   
        &TRAFFICPOLICYINSTANCE_MEMBER_HOSTED_ZONE_ID,
  211    211   
        &TRAFFICPOLICYINSTANCE_MEMBER_NAME,
  212    212   
        &TRAFFICPOLICYINSTANCE_MEMBER_TTL,
@@ -241,241 +350,369 @@
  261    261   
        }
  262    262   
        {
  263    263   
            let val = &self.traffic_policy_type;
  264    264   
            ser.write_string(&TRAFFICPOLICYINSTANCE_MEMBER_TRAFFIC_POLICY_TYPE, val.as_str())?;
  265    265   
        }
  266    266   
        Ok(())
  267    267   
    }
  268    268   
}
  269    269   
impl TrafficPolicyInstance {
  270    270   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  271         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  272         -
        deserializer: &mut D,
         271  +
    pub fn deserialize(
         272  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  273    273   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  274    274   
        #[allow(unused_variables, unused_mut)]
  275    275   
        let mut builder = Self::builder();
  276    276   
        #[allow(
  277    277   
            unused_variables,
  278    278   
            unreachable_code,
  279    279   
            clippy::single_match,
  280    280   
            clippy::match_single_binding,
  281    281   
            clippy::diverging_sub_expression
  282    282   
        )]
  283         -
        deserializer.read_struct(&TRAFFICPOLICYINSTANCE_SCHEMA, (), |_, member, deser| {
         283  +
        deserializer.read_struct(&TRAFFICPOLICYINSTANCE_SCHEMA, &mut |member, deser| {
  284    284   
            match member.member_index() {
  285    285   
                Some(0) => {
  286    286   
                    builder.id = Some(deser.read_string(member)?);
  287    287   
                }
  288    288   
                Some(1) => {
  289    289   
                    builder.hosted_zone_id = Some(deser.read_string(member)?);
  290    290   
                }
  291    291   
                Some(2) => {
  292    292   
                    builder.name = Some(deser.read_string(member)?);
  293    293   
                }
  294    294   
                Some(3) => {
  295    295   
                    builder.ttl = Some(deser.read_long(member)?);
  296    296   
                }
  297    297   
                Some(4) => {
  298    298   
                    builder.state = Some(deser.read_string(member)?);
  299    299   
                }
  300    300   
                Some(5) => {
  301    301   
                    builder.message = Some(deser.read_string(member)?);
  302    302   
                }
  303    303   
                Some(6) => {
  304    304   
                    builder.traffic_policy_id = Some(deser.read_string(member)?);
  305    305   
                }
  306    306   
                Some(7) => {
  307    307   
                    builder.traffic_policy_version = Some(deser.read_integer(member)?);
  308    308   
                }
  309    309   
                Some(8) => {
  310    310   
                    builder.traffic_policy_type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
  311    311   
                }
  312    312   
                _ => {}
  313    313   
            }
  314    314   
            Ok(())
  315    315   
        })?;
         316  +
        builder.id = builder.id.or(Some(String::new()));
         317  +
        builder.hosted_zone_id = builder.hosted_zone_id.or(Some(String::new()));
         318  +
        builder.name = builder.name.or(Some(String::new()));
         319  +
        builder.ttl = builder.ttl.or(Some(0i64));
         320  +
        builder.state = builder.state.or(Some(String::new()));
         321  +
        builder.message = builder.message.or(Some(String::new()));
         322  +
        builder.traffic_policy_id = builder.traffic_policy_id.or(Some(String::new()));
         323  +
        builder.traffic_policy_version = builder.traffic_policy_version.or(Some(0i32));
  316    324   
        builder
  317    325   
            .build()
  318    326   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  319    327   
    }
  320    328   
}
         329  +
impl TrafficPolicyInstance {
         330  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         331  +
    pub fn deserialize_with_response(
         332  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         333  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         334  +
        _status: u16,
         335  +
        _body: &[u8],
         336  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         337  +
        Self::deserialize(deserializer)
         338  +
    }
         339  +
}
  321    340   
impl TrafficPolicyInstance {
  322    341   
    /// Creates a new builder-style object to manufacture [`TrafficPolicyInstance`](crate::types::TrafficPolicyInstance).
  323    342   
    pub fn builder() -> crate::types::builders::TrafficPolicyInstanceBuilder {
  324    343   
        crate::types::builders::TrafficPolicyInstanceBuilder::default()
  325    344   
    }
  326    345   
}
  327    346   
  328    347   
/// A builder for [`TrafficPolicyInstance`](crate::types::TrafficPolicyInstance).
  329    348   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  330    349   
#[non_exhaustive]

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

@@ -24,24 +210,225 @@
   44     44   
    "com.amazonaws.route53",
   45     45   
    "TrafficPolicySummary",
   46     46   
);
   47     47   
static TRAFFICPOLICYSUMMARY_MEMBER_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   48     48   
    ::aws_smithy_schema::ShapeId::from_static(
   49     49   
        "com.amazonaws.route53#TrafficPolicySummary$Id",
   50     50   
        "com.amazonaws.route53",
   51     51   
        "TrafficPolicySummary",
   52     52   
    ),
   53     53   
    ::aws_smithy_schema::ShapeType::String,
   54         -
    "id",
          54  +
    "Id",
   55     55   
    0,
   56     56   
);
   57     57   
static TRAFFICPOLICYSUMMARY_MEMBER_NAME: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   58     58   
    ::aws_smithy_schema::ShapeId::from_static(
   59     59   
        "com.amazonaws.route53#TrafficPolicySummary$Name",
   60     60   
        "com.amazonaws.route53",
   61     61   
        "TrafficPolicySummary",
   62     62   
    ),
   63     63   
    ::aws_smithy_schema::ShapeType::String,
   64         -
    "name",
          64  +
    "Name",
   65     65   
    1,
   66     66   
);
   67     67   
static TRAFFICPOLICYSUMMARY_MEMBER_TYPE: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   68     68   
    ::aws_smithy_schema::ShapeId::from_static(
   69     69   
        "com.amazonaws.route53#TrafficPolicySummary$Type",
   70     70   
        "com.amazonaws.route53",
   71     71   
        "TrafficPolicySummary",
   72     72   
    ),
   73     73   
    ::aws_smithy_schema::ShapeType::String,
   74         -
    "r##type",
          74  +
    "Type",
   75     75   
    2,
   76     76   
);
   77     77   
static TRAFFICPOLICYSUMMARY_MEMBER_LATEST_VERSION: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   78     78   
    ::aws_smithy_schema::ShapeId::from_static(
   79     79   
        "com.amazonaws.route53#TrafficPolicySummary$LatestVersion",
   80     80   
        "com.amazonaws.route53",
   81     81   
        "TrafficPolicySummary",
   82     82   
    ),
   83     83   
    ::aws_smithy_schema::ShapeType::Integer,
   84         -
    "latest_version",
          84  +
    "LatestVersion",
   85     85   
    3,
   86     86   
);
   87     87   
static TRAFFICPOLICYSUMMARY_MEMBER_TRAFFIC_POLICY_COUNT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   88     88   
    ::aws_smithy_schema::ShapeId::from_static(
   89     89   
        "com.amazonaws.route53#TrafficPolicySummary$TrafficPolicyCount",
   90     90   
        "com.amazonaws.route53",
   91     91   
        "TrafficPolicySummary",
   92     92   
    ),
   93     93   
    ::aws_smithy_schema::ShapeType::Integer,
   94         -
    "traffic_policy_count",
          94  +
    "TrafficPolicyCount",
   95     95   
    4,
   96     96   
);
   97     97   
static TRAFFICPOLICYSUMMARY_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   98     98   
    TRAFFICPOLICYSUMMARY_SCHEMA_ID,
   99     99   
    ::aws_smithy_schema::ShapeType::Structure,
  100    100   
    &[
  101    101   
        &TRAFFICPOLICYSUMMARY_MEMBER_ID,
  102    102   
        &TRAFFICPOLICYSUMMARY_MEMBER_NAME,
  103    103   
        &TRAFFICPOLICYSUMMARY_MEMBER_TYPE,
  104    104   
        &TRAFFICPOLICYSUMMARY_MEMBER_LATEST_VERSION,
  105    105   
        &TRAFFICPOLICYSUMMARY_MEMBER_TRAFFIC_POLICY_COUNT,
  106    106   
    ],
  107    107   
);
  108    108   
impl TrafficPolicySummary {
  109    109   
    /// The schema for this shape.
  110    110   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &TRAFFICPOLICYSUMMARY_SCHEMA;
  111    111   
}
  112    112   
impl ::aws_smithy_schema::serde::SerializableStruct for TrafficPolicySummary {
  113    113   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  114    114   
    fn serialize_members(
  115    115   
        &self,
  116    116   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  117    117   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  118    118   
        {
  119    119   
            let val = &self.id;
  120    120   
            ser.write_string(&TRAFFICPOLICYSUMMARY_MEMBER_ID, val)?;
  121    121   
        }
  122    122   
        {
  123    123   
            let val = &self.name;
  124    124   
            ser.write_string(&TRAFFICPOLICYSUMMARY_MEMBER_NAME, val)?;
  125    125   
        }
  126    126   
        {
  127    127   
            let val = &self.r#type;
  128    128   
            ser.write_string(&TRAFFICPOLICYSUMMARY_MEMBER_TYPE, val.as_str())?;
  129    129   
        }
  130    130   
        {
  131    131   
            let val = &self.latest_version;
  132    132   
            ser.write_integer(&TRAFFICPOLICYSUMMARY_MEMBER_LATEST_VERSION, *val)?;
  133    133   
        }
  134    134   
        {
  135    135   
            let val = &self.traffic_policy_count;
  136    136   
            ser.write_integer(&TRAFFICPOLICYSUMMARY_MEMBER_TRAFFIC_POLICY_COUNT, *val)?;
  137    137   
        }
  138    138   
        Ok(())
  139    139   
    }
  140    140   
}
  141    141   
impl TrafficPolicySummary {
  142    142   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  143         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  144         -
        deserializer: &mut D,
         143  +
    pub fn deserialize(
         144  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  145    145   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  146    146   
        #[allow(unused_variables, unused_mut)]
  147    147   
        let mut builder = Self::builder();
  148    148   
        #[allow(
  149    149   
            unused_variables,
  150    150   
            unreachable_code,
  151    151   
            clippy::single_match,
  152    152   
            clippy::match_single_binding,
  153    153   
            clippy::diverging_sub_expression
  154    154   
        )]
  155         -
        deserializer.read_struct(&TRAFFICPOLICYSUMMARY_SCHEMA, (), |_, member, deser| {
         155  +
        deserializer.read_struct(&TRAFFICPOLICYSUMMARY_SCHEMA, &mut |member, deser| {
  156    156   
            match member.member_index() {
  157    157   
                Some(0) => {
  158    158   
                    builder.id = Some(deser.read_string(member)?);
  159    159   
                }
  160    160   
                Some(1) => {
  161    161   
                    builder.name = Some(deser.read_string(member)?);
  162    162   
                }
  163    163   
                Some(2) => {
  164    164   
                    builder.r#type = Some(crate::types::RrType::from(deser.read_string(member)?.as_str()));
  165    165   
                }
  166    166   
                Some(3) => {
  167    167   
                    builder.latest_version = Some(deser.read_integer(member)?);
  168    168   
                }
  169    169   
                Some(4) => {
  170    170   
                    builder.traffic_policy_count = Some(deser.read_integer(member)?);
  171    171   
                }
  172    172   
                _ => {}
  173    173   
            }
  174    174   
            Ok(())
  175    175   
        })?;
         176  +
        builder.id = builder.id.or(Some(String::new()));
         177  +
        builder.name = builder.name.or(Some(String::new()));
         178  +
        builder.latest_version = builder.latest_version.or(Some(0i32));
         179  +
        builder.traffic_policy_count = builder.traffic_policy_count.or(Some(0i32));
  176    180   
        builder
  177    181   
            .build()
  178    182   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  179    183   
    }
  180    184   
}
         185  +
impl TrafficPolicySummary {
         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  +
}
  181    196   
impl TrafficPolicySummary {
  182    197   
    /// Creates a new builder-style object to manufacture [`TrafficPolicySummary`](crate::types::TrafficPolicySummary).
  183    198   
    pub fn builder() -> crate::types::builders::TrafficPolicySummaryBuilder {
  184    199   
        crate::types::builders::TrafficPolicySummaryBuilder::default()
  185    200   
    }
  186    201   
}
  187    202   
  188    203   
/// A builder for [`TrafficPolicySummary`](crate::types::TrafficPolicySummary).
  189    204   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  190    205   
#[non_exhaustive]