AWS SDK

AWS SDK

rev. e063993ca0ab793f44c575dbe707d50a5e3e2406 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key/_generate_data_key_input.rs

@@ -83,83 +203,203 @@
  103    103   
    "com.amazonaws.kms.synthetic",
  104    104   
    "GenerateDataKeyInput",
  105    105   
);
  106    106   
static GENERATEDATAKEYINPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$KeyId",
  109    109   
        "com.amazonaws.kms.synthetic",
  110    110   
        "GenerateDataKeyInput",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "key_id",
         113  +
    "KeyId",
  114    114   
    0,
  115    115   
);
  116    116   
static GENERATEDATAKEYINPUT_MEMBER_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$EncryptionContext",
  119    119   
        "com.amazonaws.kms.synthetic",
  120    120   
        "GenerateDataKeyInput",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::Map,
  123         -
    "encryption_context",
         123  +
    "EncryptionContext",
  124    124   
    1,
  125    125   
);
  126    126   
static GENERATEDATAKEYINPUT_MEMBER_NUMBER_OF_BYTES: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$NumberOfBytes",
  129    129   
        "com.amazonaws.kms.synthetic",
  130    130   
        "GenerateDataKeyInput",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::Integer,
  133         -
    "number_of_bytes",
         133  +
    "NumberOfBytes",
  134    134   
    2,
  135    135   
);
  136    136   
static GENERATEDATAKEYINPUT_MEMBER_KEY_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  137    137   
    ::aws_smithy_schema::ShapeId::from_static(
  138    138   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$KeySpec",
  139    139   
        "com.amazonaws.kms.synthetic",
  140    140   
        "GenerateDataKeyInput",
  141    141   
    ),
  142    142   
    ::aws_smithy_schema::ShapeType::String,
  143         -
    "key_spec",
         143  +
    "KeySpec",
  144    144   
    3,
  145    145   
);
  146    146   
static GENERATEDATAKEYINPUT_MEMBER_GRANT_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  147    147   
    ::aws_smithy_schema::ShapeId::from_static(
  148    148   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$GrantTokens",
  149    149   
        "com.amazonaws.kms.synthetic",
  150    150   
        "GenerateDataKeyInput",
  151    151   
    ),
  152    152   
    ::aws_smithy_schema::ShapeType::List,
  153         -
    "grant_tokens",
         153  +
    "GrantTokens",
  154    154   
    4,
  155    155   
);
  156    156   
static GENERATEDATAKEYINPUT_MEMBER_RECIPIENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  157    157   
    ::aws_smithy_schema::ShapeId::from_static(
  158    158   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$Recipient",
  159    159   
        "com.amazonaws.kms.synthetic",
  160    160   
        "GenerateDataKeyInput",
  161    161   
    ),
  162    162   
    ::aws_smithy_schema::ShapeType::Structure,
  163         -
    "recipient",
         163  +
    "Recipient",
  164    164   
    5,
  165    165   
);
  166    166   
static GENERATEDATAKEYINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  167    167   
    ::aws_smithy_schema::ShapeId::from_static(
  168    168   
        "com.amazonaws.kms.synthetic#GenerateDataKeyInput$DryRun",
  169    169   
        "com.amazonaws.kms.synthetic",
  170    170   
        "GenerateDataKeyInput",
  171    171   
    ),
  172    172   
    ::aws_smithy_schema::ShapeType::Boolean,
  173         -
    "dry_run",
         173  +
    "DryRun",
  174    174   
    6,
  175    175   
);
  176    176   
static GENERATEDATAKEYINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  177    177   
    GENERATEDATAKEYINPUT_SCHEMA_ID,
  178    178   
    ::aws_smithy_schema::ShapeType::Structure,
  179    179   
    &[
  180    180   
        &GENERATEDATAKEYINPUT_MEMBER_KEY_ID,
  181    181   
        &GENERATEDATAKEYINPUT_MEMBER_ENCRYPTION_CONTEXT,
  182    182   
        &GENERATEDATAKEYINPUT_MEMBER_NUMBER_OF_BYTES,
  183    183   
        &GENERATEDATAKEYINPUT_MEMBER_KEY_SPEC,
@@ -212,212 +335,327 @@
  232    232   
            ser.write_struct(&GENERATEDATAKEYINPUT_MEMBER_RECIPIENT, val)?;
  233    233   
        }
  234    234   
        if let Some(ref val) = self.dry_run {
  235    235   
            ser.write_boolean(&GENERATEDATAKEYINPUT_MEMBER_DRY_RUN, *val)?;
  236    236   
        }
  237    237   
        Ok(())
  238    238   
    }
  239    239   
}
  240    240   
impl GenerateDataKeyInput {
  241    241   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  242         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  243         -
        deserializer: &mut D,
         242  +
    pub fn deserialize(
         243  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  244    244   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  245    245   
        #[allow(unused_variables, unused_mut)]
  246    246   
        let mut builder = Self::builder();
  247    247   
        #[allow(
  248    248   
            unused_variables,
  249    249   
            unreachable_code,
  250    250   
            clippy::single_match,
  251    251   
            clippy::match_single_binding,
  252    252   
            clippy::diverging_sub_expression
  253    253   
        )]
  254         -
        deserializer.read_struct(&GENERATEDATAKEYINPUT_SCHEMA, (), |_, member, deser| {
         254  +
        deserializer.read_struct(&GENERATEDATAKEYINPUT_SCHEMA, &mut |member, deser| {
  255    255   
            match member.member_index() {
  256    256   
                Some(0) => {
  257    257   
                    builder.key_id = Some(deser.read_string(member)?);
  258    258   
                }
  259    259   
                Some(1) => {
  260         -
                    builder.encryption_context = Some({
  261         -
                        let container = if let Some(cap) = deser.container_size() {
  262         -
                            std::collections::HashMap::with_capacity(cap)
  263         -
                        } else {
  264         -
                            std::collections::HashMap::new()
  265         -
                        };
  266         -
                        deser.read_map(member, container, |mut map, key, deser| {
  267         -
                            map.insert(key, deser.read_string(member)?);
  268         -
                            Ok(map)
  269         -
                        })?
  270         -
                    });
         260  +
                    builder.encryption_context = Some(deser.read_string_string_map(member)?);
  271    261   
                }
  272    262   
                Some(2) => {
  273    263   
                    builder.number_of_bytes = Some(deser.read_integer(member)?);
  274    264   
                }
  275    265   
                Some(3) => {
  276    266   
                    builder.key_spec = Some(crate::types::DataKeySpec::from(deser.read_string(member)?.as_str()));
  277    267   
                }
  278    268   
                Some(4) => {
  279         -
                    builder.grant_tokens = Some({
  280         -
                        let container = if let Some(cap) = deser.container_size() {
  281         -
                            Vec::with_capacity(cap)
  282         -
                        } else {
  283         -
                            Vec::new()
  284         -
                        };
  285         -
                        deser.read_list(member, container, |mut list, deser| {
  286         -
                            list.push(deser.read_string(member)?);
  287         -
                            Ok(list)
  288         -
                        })?
  289         -
                    });
         269  +
                    builder.grant_tokens = Some(deser.read_string_list(member)?);
  290    270   
                }
  291    271   
                Some(5) => {
  292    272   
                    builder.recipient = Some(crate::types::RecipientInfo::deserialize(deser)?);
  293    273   
                }
  294    274   
                Some(6) => {
  295    275   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  296    276   
                }
  297    277   
                _ => {}
  298    278   
            }
  299    279   
            Ok(())
  300    280   
        })?;
         281  +
        builder.key_id = builder.key_id.or(Some(String::new()));
  301    282   
        builder
  302    283   
            .build()
  303    284   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  304    285   
    }
  305    286   
}
         287  +
impl GenerateDataKeyInput {
         288  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         289  +
    pub fn deserialize_with_response(
         290  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         291  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         292  +
        _status: u16,
         293  +
        _body: &[u8],
         294  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         295  +
        Self::deserialize(deserializer)
         296  +
    }
         297  +
}
  306    298   
impl GenerateDataKeyInput {
  307    299   
    /// Creates a new builder-style object to manufacture [`GenerateDataKeyInput`](crate::operation::generate_data_key::GenerateDataKeyInput).
  308    300   
    pub fn builder() -> crate::operation::generate_data_key::builders::GenerateDataKeyInputBuilder {
  309    301   
        crate::operation::generate_data_key::builders::GenerateDataKeyInputBuilder::default()
  310    302   
    }
  311    303   
}
  312    304   
  313    305   
/// A builder for [`GenerateDataKeyInput`](crate::operation::generate_data_key::GenerateDataKeyInput).
  314    306   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  315    307   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key/_generate_data_key_output.rs

@@ -38,38 +194,251 @@
   58     58   
    "com.amazonaws.kms.synthetic",
   59     59   
    "GenerateDataKeyOutput",
   60     60   
);
   61     61   
static GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   62     62   
    ::aws_smithy_schema::ShapeId::from_static(
   63     63   
        "com.amazonaws.kms.synthetic#GenerateDataKeyOutput$CiphertextBlob",
   64     64   
        "com.amazonaws.kms.synthetic",
   65     65   
        "GenerateDataKeyOutput",
   66     66   
    ),
   67     67   
    ::aws_smithy_schema::ShapeType::Blob,
   68         -
    "ciphertext_blob",
          68  +
    "CiphertextBlob",
   69     69   
    0,
   70     70   
);
   71     71   
static GENERATEDATAKEYOUTPUT_MEMBER_PLAINTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   72     72   
    ::aws_smithy_schema::ShapeId::from_static(
   73     73   
        "com.amazonaws.kms.synthetic#GenerateDataKeyOutput$Plaintext",
   74     74   
        "com.amazonaws.kms.synthetic",
   75     75   
        "GenerateDataKeyOutput",
   76     76   
    ),
   77     77   
    ::aws_smithy_schema::ShapeType::Blob,
   78         -
    "plaintext",
          78  +
    "Plaintext",
   79     79   
    1,
   80     80   
);
   81     81   
static GENERATEDATAKEYOUTPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   82     82   
    ::aws_smithy_schema::ShapeId::from_static(
   83     83   
        "com.amazonaws.kms.synthetic#GenerateDataKeyOutput$KeyId",
   84     84   
        "com.amazonaws.kms.synthetic",
   85     85   
        "GenerateDataKeyOutput",
   86     86   
    ),
   87     87   
    ::aws_smithy_schema::ShapeType::String,
   88         -
    "key_id",
          88  +
    "KeyId",
   89     89   
    2,
   90     90   
);
   91     91   
static GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   92     92   
    ::aws_smithy_schema::ShapeId::from_static(
   93     93   
        "com.amazonaws.kms.synthetic#GenerateDataKeyOutput$CiphertextForRecipient",
   94     94   
        "com.amazonaws.kms.synthetic",
   95     95   
        "GenerateDataKeyOutput",
   96     96   
    ),
   97     97   
    ::aws_smithy_schema::ShapeType::Blob,
   98         -
    "ciphertext_for_recipient",
          98  +
    "CiphertextForRecipient",
   99     99   
    3,
  100    100   
);
  101    101   
static GENERATEDATAKEYOUTPUT_MEMBER_KEY_MATERIAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  102    102   
    ::aws_smithy_schema::ShapeId::from_static(
  103    103   
        "com.amazonaws.kms.synthetic#GenerateDataKeyOutput$KeyMaterialId",
  104    104   
        "com.amazonaws.kms.synthetic",
  105    105   
        "GenerateDataKeyOutput",
  106    106   
    ),
  107    107   
    ::aws_smithy_schema::ShapeType::String,
  108         -
    "key_material_id",
         108  +
    "KeyMaterialId",
  109    109   
    4,
  110    110   
);
         111  +
static GENERATEDATAKEYOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         112  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         113  +
    ::aws_smithy_schema::ShapeType::String,
         114  +
    "request_id",
         115  +
    5,
         116  +
)
         117  +
.with_http_header("x-amzn-requestid");
  111    118   
static GENERATEDATAKEYOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  112    119   
    GENERATEDATAKEYOUTPUT_SCHEMA_ID,
  113    120   
    ::aws_smithy_schema::ShapeType::Structure,
  114    121   
    &[
  115    122   
        &GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_BLOB,
  116    123   
        &GENERATEDATAKEYOUTPUT_MEMBER_PLAINTEXT,
  117    124   
        &GENERATEDATAKEYOUTPUT_MEMBER_KEY_ID,
  118    125   
        &GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT,
  119    126   
        &GENERATEDATAKEYOUTPUT_MEMBER_KEY_MATERIAL_ID,
         127  +
        &GENERATEDATAKEYOUTPUT_MEMBER__REQUEST_ID,
  120    128   
    ],
  121    129   
);
  122    130   
impl GenerateDataKeyOutput {
  123    131   
    /// The schema for this shape.
  124    132   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GENERATEDATAKEYOUTPUT_SCHEMA;
  125    133   
}
  126    134   
impl ::aws_smithy_schema::serde::SerializableStruct for GenerateDataKeyOutput {
  127    135   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  128    136   
    fn serialize_members(
  129    137   
        &self,
  130    138   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  131    139   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  132    140   
        if let Some(ref val) = self.ciphertext_blob {
  133    141   
            ser.write_blob(&GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_BLOB, val)?;
  134    142   
        }
  135    143   
        if let Some(ref val) = self.plaintext {
  136    144   
            ser.write_blob(&GENERATEDATAKEYOUTPUT_MEMBER_PLAINTEXT, val)?;
  137    145   
        }
  138    146   
        if let Some(ref val) = self.key_id {
  139    147   
            ser.write_string(&GENERATEDATAKEYOUTPUT_MEMBER_KEY_ID, val)?;
  140    148   
        }
  141    149   
        if let Some(ref val) = self.ciphertext_for_recipient {
  142    150   
            ser.write_blob(&GENERATEDATAKEYOUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT, val)?;
  143    151   
        }
  144    152   
        if let Some(ref val) = self.key_material_id {
  145    153   
            ser.write_string(&GENERATEDATAKEYOUTPUT_MEMBER_KEY_MATERIAL_ID, val)?;
  146    154   
        }
  147    155   
        Ok(())
  148    156   
    }
  149    157   
}
  150    158   
impl GenerateDataKeyOutput {
  151    159   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  152         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  153         -
        deserializer: &mut D,
         160  +
    pub fn deserialize(
         161  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  154    162   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  155    163   
        #[allow(unused_variables, unused_mut)]
  156    164   
        let mut builder = Self::builder();
  157    165   
        #[allow(
  158    166   
            unused_variables,
  159    167   
            unreachable_code,
  160    168   
            clippy::single_match,
  161    169   
            clippy::match_single_binding,
  162    170   
            clippy::diverging_sub_expression
  163    171   
        )]
  164         -
        deserializer.read_struct(&GENERATEDATAKEYOUTPUT_SCHEMA, (), |_, member, deser| {
         172  +
        deserializer.read_struct(&GENERATEDATAKEYOUTPUT_SCHEMA, &mut |member, deser| {
         173  +
            match member.member_index() {
         174  +
                Some(0) => {
         175  +
                    builder.ciphertext_blob = Some(deser.read_blob(member)?);
         176  +
                }
         177  +
                Some(1) => {
         178  +
                    builder.plaintext = Some(deser.read_blob(member)?);
         179  +
                }
         180  +
                Some(2) => {
         181  +
                    builder.key_id = Some(deser.read_string(member)?);
         182  +
                }
         183  +
                Some(3) => {
         184  +
                    builder.ciphertext_for_recipient = Some(deser.read_blob(member)?);
         185  +
                }
         186  +
                Some(4) => {
         187  +
                    builder.key_material_id = Some(deser.read_string(member)?);
         188  +
                }
         189  +
                Some(5) => {
         190  +
                    builder._request_id = Some(deser.read_string(member)?);
         191  +
                }
         192  +
                _ => {}
         193  +
            }
         194  +
            Ok(())
         195  +
        })?;
         196  +
        Ok(builder.build())
         197  +
    }
         198  +
}
         199  +
impl GenerateDataKeyOutput {
         200  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         201  +
    /// Header-bound members are read directly from headers, avoiding runtime
         202  +
    /// member iteration overhead. Body members are read via the deserializer.
         203  +
    pub fn deserialize_with_response(
         204  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         205  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         206  +
        _status: u16,
         207  +
        _body: &[u8],
         208  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         209  +
        #[allow(unused_variables, unused_mut)]
         210  +
        let mut builder = Self::builder();
         211  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         212  +
            builder._request_id = Some(val.to_string());
         213  +
        }
         214  +
        #[allow(
         215  +
            unused_variables,
         216  +
            unreachable_code,
         217  +
            clippy::single_match,
         218  +
            clippy::match_single_binding,
         219  +
            clippy::diverging_sub_expression
         220  +
        )]
         221  +
        deserializer.read_struct(&GENERATEDATAKEYOUTPUT_SCHEMA, &mut |member, deser| {
  165    222   
            match member.member_index() {
  166    223   
                Some(0) => {
  167    224   
                    builder.ciphertext_blob = Some(deser.read_blob(member)?);
  168    225   
                }
  169    226   
                Some(1) => {
  170    227   
                    builder.plaintext = Some(deser.read_blob(member)?);
  171    228   
                }
  172    229   
                Some(2) => {
  173    230   
                    builder.key_id = Some(deser.read_string(member)?);
  174    231   
                }

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair.rs

@@ -1,1 +40,44 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GenerateDataKeyPair`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GenerateDataKeyPair;
    6      6   
impl GenerateDataKeyPair {
    7      7   
    /// Creates a new `GenerateDataKeyPair`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::generate_data_key_pair::GenerateDataKeyPairInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema = crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput::SCHEMA;
   11     15   
    pub(crate) async fn orchestrate(
   12     16   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     17   
        input: crate::operation::generate_data_key_pair::GenerateDataKeyPairInput,
   14     18   
    ) -> ::std::result::Result<
   15     19   
        crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput,
   16     20   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     21   
            crate::operation::generate_data_key_pair::GenerateDataKeyPairError,
   18     22   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     23   
        >,
   20     24   
    > {
@@ -119,123 +248,505 @@
  139    143   
                crate::operation::generate_data_key_pair::GenerateDataKeyPairError,
  140    144   
            >::new());
  141    145   
  142    146   
        ::std::borrow::Cow::Owned(rcb)
  143    147   
    }
  144    148   
}
  145    149   
  146    150   
#[derive(Debug)]
  147    151   
struct GenerateDataKeyPairResponseDeserializer;
  148    152   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GenerateDataKeyPairResponseDeserializer {
  149         -
    fn deserialize_nonstreaming(
         153  +
    fn deserialize_nonstreaming_with_config(
  150    154   
        &self,
  151    155   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         156  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  152    157   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  153    158   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  154         -
        let headers = response.headers();
  155         -
        let body = response.body().bytes().expect("body loaded");
  156    159   
        #[allow(unused_mut)]
  157    160   
        let mut force_error = false;
  158    161   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  159         -
        let parse_result = if !success && status != 200 || force_error {
  160         -
            crate::protocol_serde::shape_generate_data_key_pair::de_generate_data_key_pair_http_error(status, headers, body)
  161         -
        } else {
  162         -
            crate::protocol_serde::shape_generate_data_key_pair::de_generate_data_key_pair_http_response(status, headers, body)
         162  +
        if !success && status != 200 || force_error {
         163  +
            let headers = response.headers();
         164  +
            let body = response.body().bytes().expect("body loaded");
         165  +
            #[allow(unused_mut)]
         166  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         167  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         168  +
            })?;
         169  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         170  +
            let generic = generic_builder.build();
         171  +
            let error_code = match generic.code() {
         172  +
                ::std::option::Option::Some(code) => code,
         173  +
                ::std::option::Option::None => {
         174  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         175  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         176  +
                            crate::operation::generate_data_key_pair::GenerateDataKeyPairError::unhandled(generic),
         177  +
                        ),
         178  +
                    ))
         179  +
                }
         180  +
            };
         181  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         182  +
            let protocol = _cfg
         183  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         184  +
                .expect("a SharedClientProtocol is required");
         185  +
            let err = match error_code {
         186  +
                "DependencyTimeoutException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::DependencyTimeoutException({
         187  +
                    let mut tmp = match protocol
         188  +
                        .deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
         189  +
                        .and_then(|mut deser| {
         190  +
                            crate::types::error::DependencyTimeoutException::deserialize_with_response(
         191  +
                                &mut *deser,
         192  +
                                response.headers(),
         193  +
                                response.status().into(),
         194  +
                                body,
         195  +
                            )
         196  +
                        }) {
         197  +
                        ::std::result::Result::Ok(val) => val,
         198  +
                        ::std::result::Result::Err(e) => {
         199  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         200  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         201  +
                            ))
         202  +
                        }
         203  +
                    };
         204  +
                    tmp.meta = generic;
         205  +
                    if tmp.message.is_none() {
         206  +
                        tmp.message = _error_message;
         207  +
                    }
         208  +
                    tmp
         209  +
                }),
         210  +
                "DisabledException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::DisabledException({
         211  +
                    let mut tmp = match protocol
         212  +
                        .deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
         213  +
                        .and_then(|mut deser| {
         214  +
                            crate::types::error::DisabledException::deserialize_with_response(
         215  +
                                &mut *deser,
         216  +
                                response.headers(),
         217  +
                                response.status().into(),
         218  +
                                body,
         219  +
                            )
         220  +
                        }) {
         221  +
                        ::std::result::Result::Ok(val) => val,
         222  +
                        ::std::result::Result::Err(e) => {
         223  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         224  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         225  +
                            ))
         226  +
                        }
         227  +
                    };
         228  +
                    tmp.meta = generic;
         229  +
                    if tmp.message.is_none() {
         230  +
                        tmp.message = _error_message;
         231  +
                    }
         232  +
                    tmp
         233  +
                }),
         234  +
                "DryRunOperationException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::DryRunOperationException({
         235  +
                    let mut tmp = match protocol
         236  +
                        .deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
         237  +
                        .and_then(|mut deser| {
         238  +
                            crate::types::error::DryRunOperationException::deserialize_with_response(
         239  +
                                &mut *deser,
         240  +
                                response.headers(),
         241  +
                                response.status().into(),
         242  +
                                body,
         243  +
                            )
         244  +
                        }) {
         245  +
                        ::std::result::Result::Ok(val) => val,
         246  +
                        ::std::result::Result::Err(e) => {
         247  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         248  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         249  +
                            ))
         250  +
                        }
         251  +
                    };
         252  +
                    tmp.meta = generic;
         253  +
                    if tmp.message.is_none() {
         254  +
                        tmp.message = _error_message;
         255  +
                    }
         256  +
                    tmp
         257  +
                }),
         258  +
                "InvalidGrantTokenException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::InvalidGrantTokenException({
         259  +
                    let mut tmp = match protocol
         260  +
                        .deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
         261  +
                        .and_then(|mut deser| {
         262  +
                            crate::types::error::InvalidGrantTokenException::deserialize_with_response(
         263  +
                                &mut *deser,
         264  +
                                response.headers(),
         265  +
                                response.status().into(),
         266  +
                                body,
         267  +
                            )
         268  +
                        }) {
         269  +
                        ::std::result::Result::Ok(val) => val,
         270  +
                        ::std::result::Result::Err(e) => {
         271  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         272  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         273  +
                            ))
         274  +
                        }
         275  +
                    };
         276  +
                    tmp.meta = generic;
         277  +
                    if tmp.message.is_none() {
         278  +
                        tmp.message = _error_message;
         279  +
                    }
         280  +
                    tmp
         281  +
                }),
         282  +
                "InvalidKeyUsageException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::InvalidKeyUsageException({
         283  +
                    let mut tmp = match protocol
         284  +
                        .deserialize_response(response, crate::types::error::InvalidKeyUsageException::SCHEMA, _cfg)
         285  +
                        .and_then(|mut deser| {
         286  +
                            crate::types::error::InvalidKeyUsageException::deserialize_with_response(
         287  +
                                &mut *deser,
         288  +
                                response.headers(),
         289  +
                                response.status().into(),
         290  +
                                body,
         291  +
                            )
         292  +
                        }) {
         293  +
                        ::std::result::Result::Ok(val) => val,
         294  +
                        ::std::result::Result::Err(e) => {
         295  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         296  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         297  +
                            ))
         298  +
                        }
         299  +
                    };
         300  +
                    tmp.meta = generic;
         301  +
                    if tmp.message.is_none() {
         302  +
                        tmp.message = _error_message;
         303  +
                    }
         304  +
                    tmp
         305  +
                }),
         306  +
                "KeyUnavailableException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KeyUnavailableException({
         307  +
                    let mut tmp = match protocol
         308  +
                        .deserialize_response(response, crate::types::error::KeyUnavailableException::SCHEMA, _cfg)
         309  +
                        .and_then(|mut deser| {
         310  +
                            crate::types::error::KeyUnavailableException::deserialize_with_response(
         311  +
                                &mut *deser,
         312  +
                                response.headers(),
         313  +
                                response.status().into(),
         314  +
                                body,
         315  +
                            )
         316  +
                        }) {
         317  +
                        ::std::result::Result::Ok(val) => val,
         318  +
                        ::std::result::Result::Err(e) => {
         319  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         320  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         321  +
                            ))
         322  +
                        }
         323  +
                    };
         324  +
                    tmp.meta = generic;
         325  +
                    if tmp.message.is_none() {
         326  +
                        tmp.message = _error_message;
         327  +
                    }
         328  +
                    tmp
         329  +
                }),
         330  +
                "KMSInternalException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KmsInternalException({
         331  +
                    let mut tmp = match protocol
         332  +
                        .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
         333  +
                        .and_then(|mut deser| {
         334  +
                            crate::types::error::KmsInternalException::deserialize_with_response(
         335  +
                                &mut *deser,
         336  +
                                response.headers(),
         337  +
                                response.status().into(),
         338  +
                                body,
         339  +
                            )
         340  +
                        }) {
         341  +
                        ::std::result::Result::Ok(val) => val,
         342  +
                        ::std::result::Result::Err(e) => {
         343  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         344  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         345  +
                            ))
         346  +
                        }
         347  +
                    };
         348  +
                    tmp.meta = generic;
         349  +
                    if tmp.message.is_none() {
         350  +
                        tmp.message = _error_message;
         351  +
                    }
         352  +
                    tmp
         353  +
                }),
         354  +
                "KMSInvalidStateException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::KmsInvalidStateException({
         355  +
                    let mut tmp = match protocol
         356  +
                        .deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
         357  +
                        .and_then(|mut deser| {
         358  +
                            crate::types::error::KmsInvalidStateException::deserialize_with_response(
         359  +
                                &mut *deser,
         360  +
                                response.headers(),
         361  +
                                response.status().into(),
         362  +
                                body,
         363  +
                            )
         364  +
                        }) {
         365  +
                        ::std::result::Result::Ok(val) => val,
         366  +
                        ::std::result::Result::Err(e) => {
         367  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         368  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         369  +
                            ))
         370  +
                        }
         371  +
                    };
         372  +
                    tmp.meta = generic;
         373  +
                    if tmp.message.is_none() {
         374  +
                        tmp.message = _error_message;
         375  +
                    }
         376  +
                    tmp
         377  +
                }),
         378  +
                "NotFoundException" => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::NotFoundException({
         379  +
                    let mut tmp = match protocol
         380  +
                        .deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
         381  +
                        .and_then(|mut deser| {
         382  +
                            crate::types::error::NotFoundException::deserialize_with_response(
         383  +
                                &mut *deser,
         384  +
                                response.headers(),
         385  +
                                response.status().into(),
         386  +
                                body,
         387  +
                            )
         388  +
                        }) {
         389  +
                        ::std::result::Result::Ok(val) => val,
         390  +
                        ::std::result::Result::Err(e) => {
         391  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         392  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         393  +
                            ))
         394  +
                        }
         395  +
                    };
         396  +
                    tmp.meta = generic;
         397  +
                    if tmp.message.is_none() {
         398  +
                        tmp.message = _error_message;
         399  +
                    }
         400  +
                    tmp
         401  +
                }),
         402  +
                "UnsupportedOperationException" => {
         403  +
                    crate::operation::generate_data_key_pair::GenerateDataKeyPairError::UnsupportedOperationException({
         404  +
                        let mut tmp = match protocol
         405  +
                            .deserialize_response(response, crate::types::error::UnsupportedOperationException::SCHEMA, _cfg)
         406  +
                            .and_then(|mut deser| {
         407  +
                                crate::types::error::UnsupportedOperationException::deserialize_with_response(
         408  +
                                    &mut *deser,
         409  +
                                    response.headers(),
         410  +
                                    response.status().into(),
         411  +
                                    body,
         412  +
                                )
         413  +
                            }) {
         414  +
                            ::std::result::Result::Ok(val) => val,
         415  +
                            ::std::result::Result::Err(e) => {
         416  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         417  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         418  +
                                ))
         419  +
                            }
         420  +
                        };
         421  +
                        tmp.meta = generic;
         422  +
                        if tmp.message.is_none() {
         423  +
                            tmp.message = _error_message;
         424  +
                        }
         425  +
                        tmp
         426  +
                    })
         427  +
                }
         428  +
                _ => crate::operation::generate_data_key_pair::GenerateDataKeyPairError::generic(generic),
  163    429   
            };
  164         -
        crate::protocol_serde::type_erase_result(parse_result)
         430  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         431  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         432  +
            ))
         433  +
        } else {
         434  +
            let protocol = _cfg
         435  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         436  +
                .expect("a SharedClientProtocol is required");
         437  +
            let mut deser = protocol
         438  +
                .deserialize_response(response, GenerateDataKeyPair::OUTPUT_SCHEMA, _cfg)
         439  +
                .map_err(|e| {
         440  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         441  +
                })?;
         442  +
            let body = response.body().bytes().expect("body loaded");
         443  +
            let output = crate::operation::generate_data_key_pair::GenerateDataKeyPairOutput::deserialize_with_response(
         444  +
                &mut *deser,
         445  +
                response.headers(),
         446  +
                response.status().into(),
         447  +
                body,
         448  +
            )
         449  +
            .map_err(|e| {
         450  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         451  +
            })?;
         452  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         453  +
        }
  165    454   
    }
  166    455   
}
  167    456   
#[derive(Debug)]
  168    457   
struct GenerateDataKeyPairRequestSerializer;
  169    458   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GenerateDataKeyPairRequestSerializer {
  170    459   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  171    460   
    fn serialize_input(
  172    461   
        &self,
  173    462   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  174    463   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  175    464   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  176    465   
        let input = input
  177    466   
            .downcast::<crate::operation::generate_data_key_pair::GenerateDataKeyPairInput>()
  178    467   
            .expect("correct type");
  179         -
        let _header_serialization_settings = _cfg
  180         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  181         -
            .cloned()
  182         -
            .unwrap_or_default();
  183         -
        let mut request_builder = {
  184         -
            #[allow(clippy::uninlined_format_args)]
  185         -
            fn uri_base(
  186         -
                _input: &crate::operation::generate_data_key_pair::GenerateDataKeyPairInput,
  187         -
                output: &mut ::std::string::String,
  188         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  189         -
                use ::std::fmt::Write as _;
  190         -
                ::std::write!(output, "/").expect("formatting should succeed");
  191         -
                ::std::result::Result::Ok(())
  192         -
            }
  193         -
            #[allow(clippy::unnecessary_wraps)]
  194         -
            fn update_http_builder(
  195         -
                input: &crate::operation::generate_data_key_pair::GenerateDataKeyPairInput,
  196         -
                builder: ::http_1x::request::Builder,
  197         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  198         -
                let mut uri = ::std::string::String::new();
  199         -
                uri_base(input, &mut uri)?;
  200         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  201         -
            }
  202         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  203         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  204         -
            builder = _header_serialization_settings.set_default_header(
  205         -
                builder,
  206         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  207         -
                "TrentService.GenerateDataKeyPair",
  208         -
            );
  209         -
            builder
  210         -
        };
  211         -
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_generate_data_key_pair::ser_generate_data_key_pair_input(
  212         -
            &input,
  213         -
        )?);
  214         -
        if let Some(content_length) = body.content_length() {
  215         -
            let content_length = content_length.to_string();
  216         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  217         -
        }
  218         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         468  +
        let protocol = _cfg
         469  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         470  +
            .expect("a SharedClientProtocol is required");
         471  +
        let mut request = protocol
         472  +
            .serialize_request(&input, GenerateDataKeyPair::INPUT_SCHEMA, "", _cfg)
         473  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         474  +
         475  +
        return ::std::result::Result::Ok(request);
  219    476   
    }
  220    477   
}
  221    478   
#[derive(Debug)]
  222    479   
struct GenerateDataKeyPairEndpointParamsInterceptor;
  223    480   
  224    481   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GenerateDataKeyPairEndpointParamsInterceptor {
  225    482   
    fn name(&self) -> &'static str {
  226    483   
        "GenerateDataKeyPairEndpointParamsInterceptor"
  227    484   
    }
  228    485

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair/_generate_data_key_pair_input.rs

@@ -75,75 +185,185 @@
   95     95   
    "com.amazonaws.kms.synthetic",
   96     96   
    "GenerateDataKeyPairInput",
   97     97   
);
   98     98   
static GENERATEDATAKEYPAIRINPUT_MEMBER_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   99     99   
    ::aws_smithy_schema::ShapeId::from_static(
  100    100   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$EncryptionContext",
  101    101   
        "com.amazonaws.kms.synthetic",
  102    102   
        "GenerateDataKeyPairInput",
  103    103   
    ),
  104    104   
    ::aws_smithy_schema::ShapeType::Map,
  105         -
    "encryption_context",
         105  +
    "EncryptionContext",
  106    106   
    0,
  107    107   
);
  108    108   
static GENERATEDATAKEYPAIRINPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  109    109   
    ::aws_smithy_schema::ShapeId::from_static(
  110    110   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$KeyId",
  111    111   
        "com.amazonaws.kms.synthetic",
  112    112   
        "GenerateDataKeyPairInput",
  113    113   
    ),
  114    114   
    ::aws_smithy_schema::ShapeType::String,
  115         -
    "key_id",
         115  +
    "KeyId",
  116    116   
    1,
  117    117   
);
  118    118   
static GENERATEDATAKEYPAIRINPUT_MEMBER_KEY_PAIR_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  119    119   
    ::aws_smithy_schema::ShapeId::from_static(
  120    120   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$KeyPairSpec",
  121    121   
        "com.amazonaws.kms.synthetic",
  122    122   
        "GenerateDataKeyPairInput",
  123    123   
    ),
  124    124   
    ::aws_smithy_schema::ShapeType::String,
  125         -
    "key_pair_spec",
         125  +
    "KeyPairSpec",
  126    126   
    2,
  127    127   
);
  128    128   
static GENERATEDATAKEYPAIRINPUT_MEMBER_GRANT_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  129    129   
    ::aws_smithy_schema::ShapeId::from_static(
  130    130   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$GrantTokens",
  131    131   
        "com.amazonaws.kms.synthetic",
  132    132   
        "GenerateDataKeyPairInput",
  133    133   
    ),
  134    134   
    ::aws_smithy_schema::ShapeType::List,
  135         -
    "grant_tokens",
         135  +
    "GrantTokens",
  136    136   
    3,
  137    137   
);
  138    138   
static GENERATEDATAKEYPAIRINPUT_MEMBER_RECIPIENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  139    139   
    ::aws_smithy_schema::ShapeId::from_static(
  140    140   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$Recipient",
  141    141   
        "com.amazonaws.kms.synthetic",
  142    142   
        "GenerateDataKeyPairInput",
  143    143   
    ),
  144    144   
    ::aws_smithy_schema::ShapeType::Structure,
  145         -
    "recipient",
         145  +
    "Recipient",
  146    146   
    4,
  147    147   
);
  148    148   
static GENERATEDATAKEYPAIRINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  149    149   
    ::aws_smithy_schema::ShapeId::from_static(
  150    150   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairInput$DryRun",
  151    151   
        "com.amazonaws.kms.synthetic",
  152    152   
        "GenerateDataKeyPairInput",
  153    153   
    ),
  154    154   
    ::aws_smithy_schema::ShapeType::Boolean,
  155         -
    "dry_run",
         155  +
    "DryRun",
  156    156   
    5,
  157    157   
);
  158    158   
static GENERATEDATAKEYPAIRINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  159    159   
    GENERATEDATAKEYPAIRINPUT_SCHEMA_ID,
  160    160   
    ::aws_smithy_schema::ShapeType::Structure,
  161    161   
    &[
  162    162   
        &GENERATEDATAKEYPAIRINPUT_MEMBER_ENCRYPTION_CONTEXT,
  163    163   
        &GENERATEDATAKEYPAIRINPUT_MEMBER_KEY_ID,
  164    164   
        &GENERATEDATAKEYPAIRINPUT_MEMBER_KEY_PAIR_SPEC,
  165    165   
        &GENERATEDATAKEYPAIRINPUT_MEMBER_GRANT_TOKENS,
@@ -190,190 +310,302 @@
  210    210   
            ser.write_struct(&GENERATEDATAKEYPAIRINPUT_MEMBER_RECIPIENT, val)?;
  211    211   
        }
  212    212   
        if let Some(ref val) = self.dry_run {
  213    213   
            ser.write_boolean(&GENERATEDATAKEYPAIRINPUT_MEMBER_DRY_RUN, *val)?;
  214    214   
        }
  215    215   
        Ok(())
  216    216   
    }
  217    217   
}
  218    218   
impl GenerateDataKeyPairInput {
  219    219   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  220         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  221         -
        deserializer: &mut D,
         220  +
    pub fn deserialize(
         221  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  222    222   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  223    223   
        #[allow(unused_variables, unused_mut)]
  224    224   
        let mut builder = Self::builder();
  225    225   
        #[allow(
  226    226   
            unused_variables,
  227    227   
            unreachable_code,
  228    228   
            clippy::single_match,
  229    229   
            clippy::match_single_binding,
  230    230   
            clippy::diverging_sub_expression
  231    231   
        )]
  232         -
        deserializer.read_struct(&GENERATEDATAKEYPAIRINPUT_SCHEMA, (), |_, member, deser| {
         232  +
        deserializer.read_struct(&GENERATEDATAKEYPAIRINPUT_SCHEMA, &mut |member, deser| {
  233    233   
            match member.member_index() {
  234    234   
                Some(0) => {
  235         -
                    builder.encryption_context = Some({
  236         -
                        let container = if let Some(cap) = deser.container_size() {
  237         -
                            std::collections::HashMap::with_capacity(cap)
  238         -
                        } else {
  239         -
                            std::collections::HashMap::new()
  240         -
                        };
  241         -
                        deser.read_map(member, container, |mut map, key, deser| {
  242         -
                            map.insert(key, deser.read_string(member)?);
  243         -
                            Ok(map)
  244         -
                        })?
  245         -
                    });
         235  +
                    builder.encryption_context = Some(deser.read_string_string_map(member)?);
  246    236   
                }
  247    237   
                Some(1) => {
  248    238   
                    builder.key_id = Some(deser.read_string(member)?);
  249    239   
                }
  250    240   
                Some(2) => {
  251    241   
                    builder.key_pair_spec = Some(crate::types::DataKeyPairSpec::from(deser.read_string(member)?.as_str()));
  252    242   
                }
  253    243   
                Some(3) => {
  254         -
                    builder.grant_tokens = Some({
  255         -
                        let container = if let Some(cap) = deser.container_size() {
  256         -
                            Vec::with_capacity(cap)
  257         -
                        } else {
  258         -
                            Vec::new()
  259         -
                        };
  260         -
                        deser.read_list(member, container, |mut list, deser| {
  261         -
                            list.push(deser.read_string(member)?);
  262         -
                            Ok(list)
  263         -
                        })?
  264         -
                    });
         244  +
                    builder.grant_tokens = Some(deser.read_string_list(member)?);
  265    245   
                }
  266    246   
                Some(4) => {
  267    247   
                    builder.recipient = Some(crate::types::RecipientInfo::deserialize(deser)?);
  268    248   
                }
  269    249   
                Some(5) => {
  270    250   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  271    251   
                }
  272    252   
                _ => {}
  273    253   
            }
  274    254   
            Ok(())
  275    255   
        })?;
         256  +
        builder.key_id = builder.key_id.or(Some(String::new()));
  276    257   
        builder
  277    258   
            .build()
  278    259   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  279    260   
    }
  280    261   
}
         262  +
impl GenerateDataKeyPairInput {
         263  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         264  +
    pub fn deserialize_with_response(
         265  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         266  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         267  +
        _status: u16,
         268  +
        _body: &[u8],
         269  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         270  +
        Self::deserialize(deserializer)
         271  +
    }
         272  +
}
  281    273   
impl GenerateDataKeyPairInput {
  282    274   
    /// Creates a new builder-style object to manufacture [`GenerateDataKeyPairInput`](crate::operation::generate_data_key_pair::GenerateDataKeyPairInput).
  283    275   
    pub fn builder() -> crate::operation::generate_data_key_pair::builders::GenerateDataKeyPairInputBuilder {
  284    276   
        crate::operation::generate_data_key_pair::builders::GenerateDataKeyPairInputBuilder::default()
  285    277   
    }
  286    278   
}
  287    279   
  288    280   
/// A builder for [`GenerateDataKeyPairInput`](crate::operation::generate_data_key_pair::GenerateDataKeyPairInput).
  289    281   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  290    282   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair/_generate_data_key_pair_output.rs

@@ -52,52 +236,299 @@
   72     72   
    "com.amazonaws.kms.synthetic",
   73     73   
    "GenerateDataKeyPairOutput",
   74     74   
);
   75     75   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   76     76   
    ::aws_smithy_schema::ShapeId::from_static(
   77     77   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$PrivateKeyCiphertextBlob",
   78     78   
        "com.amazonaws.kms.synthetic",
   79     79   
        "GenerateDataKeyPairOutput",
   80     80   
    ),
   81     81   
    ::aws_smithy_schema::ShapeType::Blob,
   82         -
    "private_key_ciphertext_blob",
          82  +
    "PrivateKeyCiphertextBlob",
   83     83   
    0,
   84     84   
);
   85     85   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_PLAINTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   86     86   
    ::aws_smithy_schema::ShapeId::from_static(
   87     87   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$PrivateKeyPlaintext",
   88     88   
        "com.amazonaws.kms.synthetic",
   89     89   
        "GenerateDataKeyPairOutput",
   90     90   
    ),
   91     91   
    ::aws_smithy_schema::ShapeType::Blob,
   92         -
    "private_key_plaintext",
          92  +
    "PrivateKeyPlaintext",
   93     93   
    1,
   94     94   
);
   95     95   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_PUBLIC_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   96     96   
    ::aws_smithy_schema::ShapeId::from_static(
   97     97   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$PublicKey",
   98     98   
        "com.amazonaws.kms.synthetic",
   99     99   
        "GenerateDataKeyPairOutput",
  100    100   
    ),
  101    101   
    ::aws_smithy_schema::ShapeType::Blob,
  102         -
    "public_key",
         102  +
    "PublicKey",
  103    103   
    2,
  104    104   
);
  105    105   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  106    106   
    ::aws_smithy_schema::ShapeId::from_static(
  107    107   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$KeyId",
  108    108   
        "com.amazonaws.kms.synthetic",
  109    109   
        "GenerateDataKeyPairOutput",
  110    110   
    ),
  111    111   
    ::aws_smithy_schema::ShapeType::String,
  112         -
    "key_id",
         112  +
    "KeyId",
  113    113   
    3,
  114    114   
);
  115    115   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_PAIR_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  116    116   
    ::aws_smithy_schema::ShapeId::from_static(
  117    117   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$KeyPairSpec",
  118    118   
        "com.amazonaws.kms.synthetic",
  119    119   
        "GenerateDataKeyPairOutput",
  120    120   
    ),
  121    121   
    ::aws_smithy_schema::ShapeType::String,
  122         -
    "key_pair_spec",
         122  +
    "KeyPairSpec",
  123    123   
    4,
  124    124   
);
  125    125   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  126    126   
    ::aws_smithy_schema::ShapeId::from_static(
  127    127   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$CiphertextForRecipient",
  128    128   
        "com.amazonaws.kms.synthetic",
  129    129   
        "GenerateDataKeyPairOutput",
  130    130   
    ),
  131    131   
    ::aws_smithy_schema::ShapeType::Blob,
  132         -
    "ciphertext_for_recipient",
         132  +
    "CiphertextForRecipient",
  133    133   
    5,
  134    134   
);
  135    135   
static GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_MATERIAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  136    136   
    ::aws_smithy_schema::ShapeId::from_static(
  137    137   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairOutput$KeyMaterialId",
  138    138   
        "com.amazonaws.kms.synthetic",
  139    139   
        "GenerateDataKeyPairOutput",
  140    140   
    ),
  141    141   
    ::aws_smithy_schema::ShapeType::String,
  142         -
    "key_material_id",
         142  +
    "KeyMaterialId",
  143    143   
    6,
  144    144   
);
         145  +
static GENERATEDATAKEYPAIROUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
         146  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
         147  +
    ::aws_smithy_schema::ShapeType::String,
         148  +
    "request_id",
         149  +
    7,
         150  +
)
         151  +
.with_http_header("x-amzn-requestid");
  145    152   
static GENERATEDATAKEYPAIROUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  146    153   
    GENERATEDATAKEYPAIROUTPUT_SCHEMA_ID,
  147    154   
    ::aws_smithy_schema::ShapeType::Structure,
  148    155   
    &[
  149    156   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB,
  150    157   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_PLAINTEXT,
  151    158   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_PUBLIC_KEY,
  152    159   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_ID,
  153    160   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_PAIR_SPEC,
  154    161   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT,
  155    162   
        &GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_MATERIAL_ID,
         163  +
        &GENERATEDATAKEYPAIROUTPUT_MEMBER__REQUEST_ID,
  156    164   
    ],
  157    165   
);
  158    166   
impl GenerateDataKeyPairOutput {
  159    167   
    /// The schema for this shape.
  160    168   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GENERATEDATAKEYPAIROUTPUT_SCHEMA;
  161    169   
}
  162    170   
impl ::aws_smithy_schema::serde::SerializableStruct for GenerateDataKeyPairOutput {
  163    171   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  164    172   
    fn serialize_members(
  165    173   
        &self,
  166    174   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  167    175   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  168    176   
        if let Some(ref val) = self.private_key_ciphertext_blob {
  169    177   
            ser.write_blob(&GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB, val)?;
  170    178   
        }
  171    179   
        if let Some(ref val) = self.private_key_plaintext {
  172    180   
            ser.write_blob(&GENERATEDATAKEYPAIROUTPUT_MEMBER_PRIVATE_KEY_PLAINTEXT, val)?;
  173    181   
        }
  174    182   
        if let Some(ref val) = self.public_key {
  175    183   
            ser.write_blob(&GENERATEDATAKEYPAIROUTPUT_MEMBER_PUBLIC_KEY, val)?;
  176    184   
        }
  177    185   
        if let Some(ref val) = self.key_id {
  178    186   
            ser.write_string(&GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_ID, val)?;
  179    187   
        }
  180    188   
        if let Some(ref val) = self.key_pair_spec {
  181    189   
            ser.write_string(&GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_PAIR_SPEC, val.as_str())?;
  182    190   
        }
  183    191   
        if let Some(ref val) = self.ciphertext_for_recipient {
  184    192   
            ser.write_blob(&GENERATEDATAKEYPAIROUTPUT_MEMBER_CIPHERTEXT_FOR_RECIPIENT, val)?;
  185    193   
        }
  186    194   
        if let Some(ref val) = self.key_material_id {
  187    195   
            ser.write_string(&GENERATEDATAKEYPAIROUTPUT_MEMBER_KEY_MATERIAL_ID, val)?;
  188    196   
        }
  189    197   
        Ok(())
  190    198   
    }
  191    199   
}
  192    200   
impl GenerateDataKeyPairOutput {
  193    201   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         202  +
    pub fn deserialize(
         203  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    204   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    205   
        #[allow(unused_variables, unused_mut)]
  198    206   
        let mut builder = Self::builder();
  199    207   
        #[allow(
  200    208   
            unused_variables,
  201    209   
            unreachable_code,
  202    210   
            clippy::single_match,
  203    211   
            clippy::match_single_binding,
  204    212   
            clippy::diverging_sub_expression
  205    213   
        )]
  206         -
        deserializer.read_struct(&GENERATEDATAKEYPAIROUTPUT_SCHEMA, (), |_, member, deser| {
         214  +
        deserializer.read_struct(&GENERATEDATAKEYPAIROUTPUT_SCHEMA, &mut |member, deser| {
         215  +
            match member.member_index() {
         216  +
                Some(0) => {
         217  +
                    builder.private_key_ciphertext_blob = Some(deser.read_blob(member)?);
         218  +
                }
         219  +
                Some(1) => {
         220  +
                    builder.private_key_plaintext = Some(deser.read_blob(member)?);
         221  +
                }
         222  +
                Some(2) => {
         223  +
                    builder.public_key = Some(deser.read_blob(member)?);
         224  +
                }
         225  +
                Some(3) => {
         226  +
                    builder.key_id = Some(deser.read_string(member)?);
         227  +
                }
         228  +
                Some(4) => {
         229  +
                    builder.key_pair_spec = Some(crate::types::DataKeyPairSpec::from(deser.read_string(member)?.as_str()));
         230  +
                }
         231  +
                Some(5) => {
         232  +
                    builder.ciphertext_for_recipient = Some(deser.read_blob(member)?);
         233  +
                }
         234  +
                Some(6) => {
         235  +
                    builder.key_material_id = Some(deser.read_string(member)?);
         236  +
                }
         237  +
                Some(7) => {
         238  +
                    builder._request_id = Some(deser.read_string(member)?);
         239  +
                }
         240  +
                _ => {}
         241  +
            }
         242  +
            Ok(())
         243  +
        })?;
         244  +
        Ok(builder.build())
         245  +
    }
         246  +
}
         247  +
impl GenerateDataKeyPairOutput {
         248  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         249  +
    /// Header-bound members are read directly from headers, avoiding runtime
         250  +
    /// member iteration overhead. Body members are read via the deserializer.
         251  +
    pub fn deserialize_with_response(
         252  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         253  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         254  +
        _status: u16,
         255  +
        _body: &[u8],
         256  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         257  +
        #[allow(unused_variables, unused_mut)]
         258  +
        let mut builder = Self::builder();
         259  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         260  +
            builder._request_id = Some(val.to_string());
         261  +
        }
         262  +
        #[allow(
         263  +
            unused_variables,
         264  +
            unreachable_code,
         265  +
            clippy::single_match,
         266  +
            clippy::match_single_binding,
         267  +
            clippy::diverging_sub_expression
         268  +
        )]
         269  +
        deserializer.read_struct(&GENERATEDATAKEYPAIROUTPUT_SCHEMA, &mut |member, deser| {
  207    270   
            match member.member_index() {
  208    271   
                Some(0) => {
  209    272   
                    builder.private_key_ciphertext_blob = Some(deser.read_blob(member)?);
  210    273   
                }
  211    274   
                Some(1) => {
  212    275   
                    builder.private_key_plaintext = Some(deser.read_blob(member)?);
  213    276   
                }
  214    277   
                Some(2) => {
  215    278   
                    builder.public_key = Some(deser.read_blob(member)?);
  216    279   
                }

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair_without_plaintext.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GenerateDataKeyPairWithoutPlaintext`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GenerateDataKeyPairWithoutPlaintext;
    6      6   
impl GenerateDataKeyPairWithoutPlaintext {
    7      7   
    /// Creates a new `GenerateDataKeyPairWithoutPlaintext`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +257,401 @@
  144    150   
                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GenerateDataKeyPairWithoutPlaintextResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GenerateDataKeyPairWithoutPlaintextResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_generate_data_key_pair_without_plaintext::de_generate_data_key_pair_without_plaintext_http_error(
  166         -
                status, headers, body,
  167         -
            )
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                ::std::option::Option::Some(code) => code,
         180  +
                ::std::option::Option::None => {
         181  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         182  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         183  +
                            crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::unhandled(generic),
         184  +
                        ),
         185  +
                    ))
         186  +
                }
         187  +
            };
         188  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         189  +
            let protocol = _cfg
         190  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         191  +
                .expect("a SharedClientProtocol is required");
         192  +
            let err = match error_code {
         193  +
"DependencyTimeoutException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::DependencyTimeoutException({
         194  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
         195  +
                        .and_then(|mut deser| crate::types::error::DependencyTimeoutException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         196  +
                    {
         197  +
                        ::std::result::Result::Ok(val) => val,
         198  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         199  +
                    };
         200  +
                    tmp.meta = generic;
         201  +
if tmp.message.is_none() {
         202  +
                                tmp.message = _error_message;
         203  +
                            }
         204  +
tmp
         205  +
}),
         206  +
"DisabledException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::DisabledException({
         207  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
         208  +
                        .and_then(|mut deser| crate::types::error::DisabledException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         209  +
                    {
         210  +
                        ::std::result::Result::Ok(val) => val,
         211  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         212  +
                    };
         213  +
                    tmp.meta = generic;
         214  +
if tmp.message.is_none() {
         215  +
                                tmp.message = _error_message;
         216  +
                            }
         217  +
tmp
         218  +
}),
         219  +
"DryRunOperationException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::DryRunOperationException({
         220  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
         221  +
                        .and_then(|mut deser| crate::types::error::DryRunOperationException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         222  +
                    {
         223  +
                        ::std::result::Result::Ok(val) => val,
         224  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         225  +
                    };
         226  +
                    tmp.meta = generic;
         227  +
if tmp.message.is_none() {
         228  +
                                tmp.message = _error_message;
         229  +
                            }
         230  +
tmp
         231  +
}),
         232  +
"InvalidGrantTokenException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::InvalidGrantTokenException({
         233  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
         234  +
                        .and_then(|mut deser| crate::types::error::InvalidGrantTokenException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         235  +
                    {
         236  +
                        ::std::result::Result::Ok(val) => val,
         237  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         238  +
                    };
         239  +
                    tmp.meta = generic;
         240  +
if tmp.message.is_none() {
         241  +
                                tmp.message = _error_message;
         242  +
                            }
         243  +
tmp
         244  +
}),
         245  +
"InvalidKeyUsageException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::InvalidKeyUsageException({
         246  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::InvalidKeyUsageException::SCHEMA, _cfg)
         247  +
                        .and_then(|mut deser| crate::types::error::InvalidKeyUsageException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         248  +
                    {
         249  +
                        ::std::result::Result::Ok(val) => val,
         250  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         251  +
                    };
         252  +
                    tmp.meta = generic;
         253  +
if tmp.message.is_none() {
         254  +
                                tmp.message = _error_message;
         255  +
                            }
         256  +
tmp
         257  +
}),
         258  +
"KeyUnavailableException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KeyUnavailableException({
         259  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::KeyUnavailableException::SCHEMA, _cfg)
         260  +
                        .and_then(|mut deser| crate::types::error::KeyUnavailableException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         261  +
                    {
         262  +
                        ::std::result::Result::Ok(val) => val,
         263  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         264  +
                    };
         265  +
                    tmp.meta = generic;
         266  +
if tmp.message.is_none() {
         267  +
                                tmp.message = _error_message;
         268  +
                            }
         269  +
tmp
         270  +
}),
         271  +
"KMSInternalException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KmsInternalException({
         272  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
         273  +
                        .and_then(|mut deser| crate::types::error::KmsInternalException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         274  +
                    {
         275  +
                        ::std::result::Result::Ok(val) => val,
         276  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         277  +
                    };
         278  +
                    tmp.meta = generic;
         279  +
if tmp.message.is_none() {
         280  +
                                tmp.message = _error_message;
         281  +
                            }
         282  +
tmp
         283  +
}),
         284  +
"KMSInvalidStateException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::KmsInvalidStateException({
         285  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
         286  +
                        .and_then(|mut deser| crate::types::error::KmsInvalidStateException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         287  +
                    {
         288  +
                        ::std::result::Result::Ok(val) => val,
         289  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         290  +
                    };
         291  +
                    tmp.meta = generic;
         292  +
if tmp.message.is_none() {
         293  +
                                tmp.message = _error_message;
         294  +
                            }
         295  +
tmp
         296  +
}),
         297  +
"NotFoundException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::NotFoundException({
         298  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
         299  +
                        .and_then(|mut deser| crate::types::error::NotFoundException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         300  +
                    {
         301  +
                        ::std::result::Result::Ok(val) => val,
         302  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         303  +
                    };
         304  +
                    tmp.meta = generic;
         305  +
if tmp.message.is_none() {
         306  +
                                tmp.message = _error_message;
         307  +
                            }
         308  +
tmp
         309  +
}),
         310  +
"UnsupportedOperationException" => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::UnsupportedOperationException({
         311  +
let mut tmp = match protocol.deserialize_response(response, crate::types::error::UnsupportedOperationException::SCHEMA, _cfg)
         312  +
                        .and_then(|mut deser| crate::types::error::UnsupportedOperationException::deserialize_with_response(&mut *deser, response.headers(), response.status().into(), body))
         313  +
                    {
         314  +
                        ::std::result::Result::Ok(val) => val,
         315  +
                        ::std::result::Result::Err(e) => return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))),
         316  +
                    };
         317  +
                    tmp.meta = generic;
         318  +
if tmp.message.is_none() {
         319  +
                                tmp.message = _error_message;
         320  +
                            }
         321  +
tmp
         322  +
}),
         323  +
_ => crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextError::generic(generic)
         324  +
};
         325  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         326  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         327  +
            ))
  168    328   
        } else {
  169         -
            crate::protocol_serde::shape_generate_data_key_pair_without_plaintext::de_generate_data_key_pair_without_plaintext_http_response(
  170         -
                status, headers, body,
         329  +
            let protocol = _cfg
         330  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         331  +
                .expect("a SharedClientProtocol is required");
         332  +
            let mut deser = protocol
         333  +
                .deserialize_response(response, GenerateDataKeyPairWithoutPlaintext::OUTPUT_SCHEMA, _cfg)
         334  +
                .map_err(|e| {
         335  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         336  +
                })?;
         337  +
            let body = response.body().bytes().expect("body loaded");
         338  +
            let output =
         339  +
                crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextOutput::deserialize_with_response(
         340  +
                    &mut *deser,
         341  +
                    response.headers(),
         342  +
                    response.status().into(),
         343  +
                    body,
  171    344   
                )
  172         -
        };
  173         -
        crate::protocol_serde::type_erase_result(parse_result)
         345  +
                .map_err(|e| {
         346  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         347  +
                })?;
         348  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         349  +
        }
  174    350   
    }
  175    351   
}
  176    352   
#[derive(Debug)]
  177    353   
struct GenerateDataKeyPairWithoutPlaintextRequestSerializer;
  178    354   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GenerateDataKeyPairWithoutPlaintextRequestSerializer {
  179    355   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  180    356   
    fn serialize_input(
  181    357   
        &self,
  182    358   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  183    359   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  184    360   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  185    361   
        let input = input
  186    362   
            .downcast::<crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput>()
  187    363   
            .expect("correct type");
  188         -
        let _header_serialization_settings = _cfg
  189         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  190         -
            .cloned()
  191         -
            .unwrap_or_default();
  192         -
        let mut request_builder = {
  193         -
            #[allow(clippy::uninlined_format_args)]
  194         -
            fn uri_base(
  195         -
                _input: &crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput,
  196         -
                output: &mut ::std::string::String,
  197         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  198         -
                use ::std::fmt::Write as _;
  199         -
                ::std::write!(output, "/").expect("formatting should succeed");
  200         -
                ::std::result::Result::Ok(())
  201         -
            }
  202         -
            #[allow(clippy::unnecessary_wraps)]
  203         -
            fn update_http_builder(
  204         -
                input: &crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput,
  205         -
                builder: ::http_1x::request::Builder,
  206         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  207         -
                let mut uri = ::std::string::String::new();
  208         -
                uri_base(input, &mut uri)?;
  209         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  210         -
            }
  211         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  212         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  213         -
            builder = _header_serialization_settings.set_default_header(
  214         -
                builder,
  215         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  216         -
                "TrentService.GenerateDataKeyPairWithoutPlaintext",
  217         -
            );
  218         -
            builder
  219         -
        };
  220         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  221         -
            crate::protocol_serde::shape_generate_data_key_pair_without_plaintext::ser_generate_data_key_pair_without_plaintext_input(&input)?,
  222         -
        );
  223         -
        if let Some(content_length) = body.content_length() {
  224         -
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226         -
        }
  227         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         364  +
        let protocol = _cfg
         365  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         366  +
            .expect("a SharedClientProtocol is required");
         367  +
        let mut request = protocol
         368  +
            .serialize_request(&input, GenerateDataKeyPairWithoutPlaintext::INPUT_SCHEMA, "", _cfg)
         369  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         370  +
         371  +
        return ::std::result::Result::Ok(request);
  228    372   
    }
  229    373   
}
  230    374   
#[derive(Debug)]
  231    375   
struct GenerateDataKeyPairWithoutPlaintextEndpointParamsInterceptor;
  232    376   
  233    377   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GenerateDataKeyPairWithoutPlaintextEndpointParamsInterceptor {
  234    378   
    fn name(&self) -> &'static str {
  235    379   
        "GenerateDataKeyPairWithoutPlaintextEndpointParamsInterceptor"
  236    380   
    }
  237    381

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair_without_plaintext/_generate_data_key_pair_without_plaintext_input.rs

@@ -63,63 +281,273 @@
   83     83   
    "com.amazonaws.kms.synthetic",
   84     84   
    "GenerateDataKeyPairWithoutPlaintextInput",
   85     85   
);
   86     86   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_ENCRYPTION_CONTEXT: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextInput$EncryptionContext",
   89     89   
        "com.amazonaws.kms.synthetic",
   90     90   
        "GenerateDataKeyPairWithoutPlaintextInput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::Map,
   93         -
    "encryption_context",
          93  +
    "EncryptionContext",
   94     94   
    0,
   95     95   
);
   96     96   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   97     97   
    ::aws_smithy_schema::ShapeId::from_static(
   98     98   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextInput$KeyId",
   99     99   
        "com.amazonaws.kms.synthetic",
  100    100   
        "GenerateDataKeyPairWithoutPlaintextInput",
  101    101   
    ),
  102    102   
    ::aws_smithy_schema::ShapeType::String,
  103         -
    "key_id",
         103  +
    "KeyId",
  104    104   
    1,
  105    105   
);
  106    106   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_PAIR_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  107    107   
    ::aws_smithy_schema::ShapeId::from_static(
  108    108   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextInput$KeyPairSpec",
  109    109   
        "com.amazonaws.kms.synthetic",
  110    110   
        "GenerateDataKeyPairWithoutPlaintextInput",
  111    111   
    ),
  112    112   
    ::aws_smithy_schema::ShapeType::String,
  113         -
    "key_pair_spec",
         113  +
    "KeyPairSpec",
  114    114   
    2,
  115    115   
);
  116    116   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_GRANT_TOKENS: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  117    117   
    ::aws_smithy_schema::ShapeId::from_static(
  118    118   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextInput$GrantTokens",
  119    119   
        "com.amazonaws.kms.synthetic",
  120    120   
        "GenerateDataKeyPairWithoutPlaintextInput",
  121    121   
    ),
  122    122   
    ::aws_smithy_schema::ShapeType::List,
  123         -
    "grant_tokens",
         123  +
    "GrantTokens",
  124    124   
    3,
  125    125   
);
  126    126   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_DRY_RUN: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
  127    127   
    ::aws_smithy_schema::ShapeId::from_static(
  128    128   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextInput$DryRun",
  129    129   
        "com.amazonaws.kms.synthetic",
  130    130   
        "GenerateDataKeyPairWithoutPlaintextInput",
  131    131   
    ),
  132    132   
    ::aws_smithy_schema::ShapeType::Boolean,
  133         -
    "dry_run",
         133  +
    "DryRun",
  134    134   
    4,
  135    135   
);
  136    136   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
  137    137   
    GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_SCHEMA_ID,
  138    138   
    ::aws_smithy_schema::ShapeType::Structure,
  139    139   
    &[
  140    140   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_ENCRYPTION_CONTEXT,
  141    141   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_ID,
  142    142   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_PAIR_SPEC,
  143    143   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_GRANT_TOKENS,
  144    144   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_DRY_RUN,
  145    145   
    ],
  146    146   
);
  147    147   
impl GenerateDataKeyPairWithoutPlaintextInput {
  148    148   
    /// The schema for this shape.
  149    149   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_SCHEMA;
  150    150   
}
  151    151   
impl ::aws_smithy_schema::serde::SerializableStruct for GenerateDataKeyPairWithoutPlaintextInput {
  152    152   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  153    153   
    fn serialize_members(
  154    154   
        &self,
  155    155   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  156    156   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  157    157   
        if let Some(ref val) = self.encryption_context {
  158    158   
            ser.write_map(
  159    159   
                &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_ENCRYPTION_CONTEXT,
  160    160   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  161    161   
                    for (key, value) in val {
  162    162   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
  163    163   
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, value)?;
  164    164   
                    }
  165    165   
                    Ok(())
  166    166   
                },
  167    167   
            )?;
  168    168   
        }
  169    169   
        if let Some(ref val) = self.key_id {
  170    170   
            ser.write_string(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_ID, val)?;
  171    171   
        }
  172    172   
        if let Some(ref val) = self.key_pair_spec {
  173    173   
            ser.write_string(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_KEY_PAIR_SPEC, val.as_str())?;
  174    174   
        }
  175    175   
        if let Some(ref val) = self.grant_tokens {
  176    176   
            ser.write_list(
  177    177   
                &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_GRANT_TOKENS,
  178    178   
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
  179    179   
                    for item in val {
  180    180   
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
  181    181   
                    }
  182    182   
                    Ok(())
  183    183   
                },
  184    184   
            )?;
  185    185   
        }
  186    186   
        if let Some(ref val) = self.dry_run {
  187    187   
            ser.write_boolean(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_MEMBER_DRY_RUN, *val)?;
  188    188   
        }
  189    189   
        Ok(())
  190    190   
    }
  191    191   
}
  192    192   
impl GenerateDataKeyPairWithoutPlaintextInput {
  193    193   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  194         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  195         -
        deserializer: &mut D,
         194  +
    pub fn deserialize(
         195  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  196    196   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  197    197   
        #[allow(unused_variables, unused_mut)]
  198    198   
        let mut builder = Self::builder();
  199    199   
        #[allow(
  200    200   
            unused_variables,
  201    201   
            unreachable_code,
  202    202   
            clippy::single_match,
  203    203   
            clippy::match_single_binding,
  204    204   
            clippy::diverging_sub_expression
  205    205   
        )]
  206         -
        deserializer.read_struct(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_SCHEMA, (), |_, member, deser| {
         206  +
        deserializer.read_struct(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTINPUT_SCHEMA, &mut |member, deser| {
  207    207   
            match member.member_index() {
  208    208   
                Some(0) => {
  209         -
                    builder.encryption_context = Some({
  210         -
                        let container = if let Some(cap) = deser.container_size() {
  211         -
                            std::collections::HashMap::with_capacity(cap)
  212         -
                        } else {
  213         -
                            std::collections::HashMap::new()
  214         -
                        };
  215         -
                        deser.read_map(member, container, |mut map, key, deser| {
  216         -
                            map.insert(key, deser.read_string(member)?);
  217         -
                            Ok(map)
  218         -
                        })?
  219         -
                    });
         209  +
                    builder.encryption_context = Some(deser.read_string_string_map(member)?);
  220    210   
                }
  221    211   
                Some(1) => {
  222    212   
                    builder.key_id = Some(deser.read_string(member)?);
  223    213   
                }
  224    214   
                Some(2) => {
  225    215   
                    builder.key_pair_spec = Some(crate::types::DataKeyPairSpec::from(deser.read_string(member)?.as_str()));
  226    216   
                }
  227    217   
                Some(3) => {
  228         -
                    builder.grant_tokens = Some({
  229         -
                        let container = if let Some(cap) = deser.container_size() {
  230         -
                            Vec::with_capacity(cap)
  231         -
                        } else {
  232         -
                            Vec::new()
  233         -
                        };
  234         -
                        deser.read_list(member, container, |mut list, deser| {
  235         -
                            list.push(deser.read_string(member)?);
  236         -
                            Ok(list)
  237         -
                        })?
  238         -
                    });
         218  +
                    builder.grant_tokens = Some(deser.read_string_list(member)?);
  239    219   
                }
  240    220   
                Some(4) => {
  241    221   
                    builder.dry_run = Some(deser.read_boolean(member)?);
  242    222   
                }
  243    223   
                _ => {}
  244    224   
            }
  245    225   
            Ok(())
  246    226   
        })?;
         227  +
        builder.key_id = builder.key_id.or(Some(String::new()));
  247    228   
        builder
  248    229   
            .build()
  249    230   
            .map_err(|e| aws_smithy_schema::serde::SerdeError::Custom { message: e.to_string() })
  250    231   
    }
  251    232   
}
         233  +
impl GenerateDataKeyPairWithoutPlaintextInput {
         234  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         235  +
    pub fn deserialize_with_response(
         236  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         237  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         238  +
        _status: u16,
         239  +
        _body: &[u8],
         240  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         241  +
        Self::deserialize(deserializer)
         242  +
    }
         243  +
}
  252    244   
impl GenerateDataKeyPairWithoutPlaintextInput {
  253    245   
    /// Creates a new builder-style object to manufacture [`GenerateDataKeyPairWithoutPlaintextInput`](crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput).
  254    246   
    pub fn builder() -> crate::operation::generate_data_key_pair_without_plaintext::builders::GenerateDataKeyPairWithoutPlaintextInputBuilder {
  255    247   
        crate::operation::generate_data_key_pair_without_plaintext::builders::GenerateDataKeyPairWithoutPlaintextInputBuilder::default()
  256    248   
    }
  257    249   
}
  258    250   
  259    251   
/// A builder for [`GenerateDataKeyPairWithoutPlaintextInput`](crate::operation::generate_data_key_pair_without_plaintext::GenerateDataKeyPairWithoutPlaintextInput).
  260    252   
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
  261    253   
#[non_exhaustive]

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_pair_without_plaintext/_generate_data_key_pair_without_plaintext_output.rs

@@ -23,23 +179,236 @@
   43     43   
    "GenerateDataKeyPairWithoutPlaintextOutput",
   44     44   
);
   45     45   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB: ::aws_smithy_schema::Schema =
   46     46   
    ::aws_smithy_schema::Schema::new_member(
   47     47   
        ::aws_smithy_schema::ShapeId::from_static(
   48     48   
            "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextOutput$PrivateKeyCiphertextBlob",
   49     49   
            "com.amazonaws.kms.synthetic",
   50     50   
            "GenerateDataKeyPairWithoutPlaintextOutput",
   51     51   
        ),
   52     52   
        ::aws_smithy_schema::ShapeType::Blob,
   53         -
        "private_key_ciphertext_blob",
          53  +
        "PrivateKeyCiphertextBlob",
   54     54   
        0,
   55     55   
    );
   56     56   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PUBLIC_KEY: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   57     57   
    ::aws_smithy_schema::ShapeId::from_static(
   58     58   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextOutput$PublicKey",
   59     59   
        "com.amazonaws.kms.synthetic",
   60     60   
        "GenerateDataKeyPairWithoutPlaintextOutput",
   61     61   
    ),
   62     62   
    ::aws_smithy_schema::ShapeType::Blob,
   63         -
    "public_key",
          63  +
    "PublicKey",
   64     64   
    1,
   65     65   
);
   66     66   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   67     67   
    ::aws_smithy_schema::ShapeId::from_static(
   68     68   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextOutput$KeyId",
   69     69   
        "com.amazonaws.kms.synthetic",
   70     70   
        "GenerateDataKeyPairWithoutPlaintextOutput",
   71     71   
    ),
   72     72   
    ::aws_smithy_schema::ShapeType::String,
   73         -
    "key_id",
          73  +
    "KeyId",
   74     74   
    2,
   75     75   
);
   76     76   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_PAIR_SPEC: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   77     77   
    ::aws_smithy_schema::ShapeId::from_static(
   78     78   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextOutput$KeyPairSpec",
   79     79   
        "com.amazonaws.kms.synthetic",
   80     80   
        "GenerateDataKeyPairWithoutPlaintextOutput",
   81     81   
    ),
   82     82   
    ::aws_smithy_schema::ShapeType::String,
   83         -
    "key_pair_spec",
          83  +
    "KeyPairSpec",
   84     84   
    3,
   85     85   
);
   86     86   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_MATERIAL_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
   87     87   
    ::aws_smithy_schema::ShapeId::from_static(
   88     88   
        "com.amazonaws.kms.synthetic#GenerateDataKeyPairWithoutPlaintextOutput$KeyMaterialId",
   89     89   
        "com.amazonaws.kms.synthetic",
   90     90   
        "GenerateDataKeyPairWithoutPlaintextOutput",
   91     91   
    ),
   92     92   
    ::aws_smithy_schema::ShapeType::String,
   93         -
    "key_material_id",
          93  +
    "KeyMaterialId",
   94     94   
    4,
   95     95   
);
          96  +
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_member(
          97  +
    ::aws_smithy_schema::ShapeId::from_static("synthetic#request_id", "synthetic", "request_id"),
          98  +
    ::aws_smithy_schema::ShapeType::String,
          99  +
    "request_id",
         100  +
    5,
         101  +
)
         102  +
.with_http_header("x-amzn-requestid");
   96    103   
static GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA: ::aws_smithy_schema::Schema = ::aws_smithy_schema::Schema::new_struct(
   97    104   
    GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA_ID,
   98    105   
    ::aws_smithy_schema::ShapeType::Structure,
   99    106   
    &[
  100    107   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB,
  101    108   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PUBLIC_KEY,
  102    109   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_ID,
  103    110   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_PAIR_SPEC,
  104    111   
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_MATERIAL_ID,
         112  +
        &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER__REQUEST_ID,
  105    113   
    ],
  106    114   
);
  107    115   
impl GenerateDataKeyPairWithoutPlaintextOutput {
  108    116   
    /// The schema for this shape.
  109    117   
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema = &GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA;
  110    118   
}
  111    119   
impl ::aws_smithy_schema::serde::SerializableStruct for GenerateDataKeyPairWithoutPlaintextOutput {
  112    120   
    #[allow(unused_variables, clippy::diverging_sub_expression)]
  113    121   
    fn serialize_members(
  114    122   
        &self,
  115    123   
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
  116    124   
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
  117    125   
        if let Some(ref val) = self.private_key_ciphertext_blob {
  118    126   
            ser.write_blob(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PRIVATE_KEY_CIPHERTEXT_BLOB, val)?;
  119    127   
        }
  120    128   
        if let Some(ref val) = self.public_key {
  121    129   
            ser.write_blob(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_PUBLIC_KEY, val)?;
  122    130   
        }
  123    131   
        if let Some(ref val) = self.key_id {
  124    132   
            ser.write_string(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_ID, val)?;
  125    133   
        }
  126    134   
        if let Some(ref val) = self.key_pair_spec {
  127    135   
            ser.write_string(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_PAIR_SPEC, val.as_str())?;
  128    136   
        }
  129    137   
        if let Some(ref val) = self.key_material_id {
  130    138   
            ser.write_string(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_MEMBER_KEY_MATERIAL_ID, val)?;
  131    139   
        }
  132    140   
        Ok(())
  133    141   
    }
  134    142   
}
  135    143   
impl GenerateDataKeyPairWithoutPlaintextOutput {
  136    144   
    /// Deserializes this structure from a [`ShapeDeserializer`].
  137         -
    pub fn deserialize<D: ::aws_smithy_schema::serde::ShapeDeserializer>(
  138         -
        deserializer: &mut D,
         145  +
    pub fn deserialize(
         146  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
  139    147   
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
  140    148   
        #[allow(unused_variables, unused_mut)]
  141    149   
        let mut builder = Self::builder();
  142    150   
        #[allow(
  143    151   
            unused_variables,
  144    152   
            unreachable_code,
  145    153   
            clippy::single_match,
  146    154   
            clippy::match_single_binding,
  147    155   
            clippy::diverging_sub_expression
  148    156   
        )]
  149         -
        deserializer.read_struct(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA, (), |_, member, deser| {
         157  +
        deserializer.read_struct(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA, &mut |member, deser| {
         158  +
            match member.member_index() {
         159  +
                Some(0) => {
         160  +
                    builder.private_key_ciphertext_blob = Some(deser.read_blob(member)?);
         161  +
                }
         162  +
                Some(1) => {
         163  +
                    builder.public_key = Some(deser.read_blob(member)?);
         164  +
                }
         165  +
                Some(2) => {
         166  +
                    builder.key_id = Some(deser.read_string(member)?);
         167  +
                }
         168  +
                Some(3) => {
         169  +
                    builder.key_pair_spec = Some(crate::types::DataKeyPairSpec::from(deser.read_string(member)?.as_str()));
         170  +
                }
         171  +
                Some(4) => {
         172  +
                    builder.key_material_id = Some(deser.read_string(member)?);
         173  +
                }
         174  +
                Some(5) => {
         175  +
                    builder._request_id = Some(deser.read_string(member)?);
         176  +
                }
         177  +
                _ => {}
         178  +
            }
         179  +
            Ok(())
         180  +
        })?;
         181  +
        Ok(builder.build())
         182  +
    }
         183  +
}
         184  +
impl GenerateDataKeyPairWithoutPlaintextOutput {
         185  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         186  +
    /// Header-bound members are read directly from headers, avoiding runtime
         187  +
    /// member iteration overhead. Body members are read via the deserializer.
         188  +
    pub fn deserialize_with_response(
         189  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         190  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         191  +
        _status: u16,
         192  +
        _body: &[u8],
         193  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         194  +
        #[allow(unused_variables, unused_mut)]
         195  +
        let mut builder = Self::builder();
         196  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         197  +
            builder._request_id = Some(val.to_string());
         198  +
        }
         199  +
        #[allow(
         200  +
            unused_variables,
         201  +
            unreachable_code,
         202  +
            clippy::single_match,
         203  +
            clippy::match_single_binding,
         204  +
            clippy::diverging_sub_expression
         205  +
        )]
         206  +
        deserializer.read_struct(&GENERATEDATAKEYPAIRWITHOUTPLAINTEXTOUTPUT_SCHEMA, &mut |member, deser| {
  150    207   
            match member.member_index() {
  151    208   
                Some(0) => {
  152    209   
                    builder.private_key_ciphertext_blob = Some(deser.read_blob(member)?);
  153    210   
                }
  154    211   
                Some(1) => {
  155    212   
                    builder.public_key = Some(deser.read_blob(member)?);
  156    213   
                }
  157    214   
                Some(2) => {
  158    215   
                    builder.key_id = Some(deser.read_string(member)?);
  159    216   
                }

tmp-codegen-diff/aws-sdk/sdk/kms/src/operation/generate_data_key_without_plaintext.rs

@@ -1,1 +40,46 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/// Orchestration and serialization glue logic for `GenerateDataKeyWithoutPlaintext`.
    3      3   
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
    4      4   
#[non_exhaustive]
    5      5   
pub struct GenerateDataKeyWithoutPlaintext;
    6      6   
impl GenerateDataKeyWithoutPlaintext {
    7      7   
    /// Creates a new `GenerateDataKeyWithoutPlaintext`
    8      8   
    pub fn new() -> Self {
    9      9   
        Self
   10     10   
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          13  +
        crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema =
          16  +
        crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput::SCHEMA;
   11     17   
    pub(crate) async fn orchestrate(
   12     18   
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
   13     19   
        input: crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextInput,
   14     20   
    ) -> ::std::result::Result<
   15     21   
        crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput,
   16     22   
        ::aws_smithy_runtime_api::client::result::SdkError<
   17     23   
            crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError,
   18     24   
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
   19     25   
        >,
   20     26   
    > {
@@ -124,130 +255,504 @@
  144    150   
                crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError,
  145    151   
            >::new());
  146    152   
  147    153   
        ::std::borrow::Cow::Owned(rcb)
  148    154   
    }
  149    155   
}
  150    156   
  151    157   
#[derive(Debug)]
  152    158   
struct GenerateDataKeyWithoutPlaintextResponseDeserializer;
  153    159   
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for GenerateDataKeyWithoutPlaintextResponseDeserializer {
  154         -
    fn deserialize_nonstreaming(
         160  +
    fn deserialize_nonstreaming_with_config(
  155    161   
        &self,
  156    162   
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         163  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
  157    164   
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
  158    165   
        let (success, status) = (response.status().is_success(), response.status().as_u16());
  159         -
        let headers = response.headers();
  160         -
        let body = response.body().bytes().expect("body loaded");
  161    166   
        #[allow(unused_mut)]
  162    167   
        let mut force_error = false;
  163    168   
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
  164         -
        let parse_result = if !success && status != 200 || force_error {
  165         -
            crate::protocol_serde::shape_generate_data_key_without_plaintext::de_generate_data_key_without_plaintext_http_error(status, headers, body)
  166         -
        } else {
  167         -
            crate::protocol_serde::shape_generate_data_key_without_plaintext::de_generate_data_key_without_plaintext_http_response(
  168         -
                status, headers, body,
         169  +
        if !success && status != 200 || force_error {
         170  +
            let headers = response.headers();
         171  +
            let body = response.body().bytes().expect("body loaded");
         172  +
            #[allow(unused_mut)]
         173  +
            let mut generic_builder = crate::protocol_serde::parse_http_error_metadata(status, headers, body).map_err(|e| {
         174  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         175  +
            })?;
         176  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         177  +
            let generic = generic_builder.build();
         178  +
            let error_code = match generic.code() {
         179  +
                ::std::option::Option::Some(code) => code,
         180  +
                ::std::option::Option::None => {
         181  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         182  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         183  +
                            crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::unhandled(generic),
         184  +
                        ),
         185  +
                    ))
         186  +
                }
         187  +
            };
         188  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         189  +
            let protocol = _cfg
         190  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         191  +
                .expect("a SharedClientProtocol is required");
         192  +
            let err = match error_code {
         193  +
                "DependencyTimeoutException" => {
         194  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::DependencyTimeoutException({
         195  +
                        let mut tmp = match protocol
         196  +
                            .deserialize_response(response, crate::types::error::DependencyTimeoutException::SCHEMA, _cfg)
         197  +
                            .and_then(|mut deser| {
         198  +
                                crate::types::error::DependencyTimeoutException::deserialize_with_response(
         199  +
                                    &mut *deser,
         200  +
                                    response.headers(),
         201  +
                                    response.status().into(),
         202  +
                                    body,
         203  +
                                )
         204  +
                            }) {
         205  +
                            ::std::result::Result::Ok(val) => val,
         206  +
                            ::std::result::Result::Err(e) => {
         207  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         208  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         209  +
                                ))
         210  +
                            }
         211  +
                        };
         212  +
                        tmp.meta = generic;
         213  +
                        if tmp.message.is_none() {
         214  +
                            tmp.message = _error_message;
         215  +
                        }
         216  +
                        tmp
         217  +
                    })
         218  +
                }
         219  +
                "DisabledException" => {
         220  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::DisabledException({
         221  +
                        let mut tmp = match protocol
         222  +
                            .deserialize_response(response, crate::types::error::DisabledException::SCHEMA, _cfg)
         223  +
                            .and_then(|mut deser| {
         224  +
                                crate::types::error::DisabledException::deserialize_with_response(
         225  +
                                    &mut *deser,
         226  +
                                    response.headers(),
         227  +
                                    response.status().into(),
         228  +
                                    body,
         229  +
                                )
         230  +
                            }) {
         231  +
                            ::std::result::Result::Ok(val) => val,
         232  +
                            ::std::result::Result::Err(e) => {
         233  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         234  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         235  +
                                ))
         236  +
                            }
         237  +
                        };
         238  +
                        tmp.meta = generic;
         239  +
                        if tmp.message.is_none() {
         240  +
                            tmp.message = _error_message;
         241  +
                        }
         242  +
                        tmp
         243  +
                    })
         244  +
                }
         245  +
                "DryRunOperationException" => {
         246  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::DryRunOperationException({
         247  +
                        let mut tmp = match protocol
         248  +
                            .deserialize_response(response, crate::types::error::DryRunOperationException::SCHEMA, _cfg)
         249  +
                            .and_then(|mut deser| {
         250  +
                                crate::types::error::DryRunOperationException::deserialize_with_response(
         251  +
                                    &mut *deser,
         252  +
                                    response.headers(),
         253  +
                                    response.status().into(),
         254  +
                                    body,
  169    255   
                                )
         256  +
                            }) {
         257  +
                            ::std::result::Result::Ok(val) => val,
         258  +
                            ::std::result::Result::Err(e) => {
         259  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         260  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         261  +
                                ))
         262  +
                            }
  170    263   
                        };
  171         -
        crate::protocol_serde::type_erase_result(parse_result)
         264  +
                        tmp.meta = generic;
         265  +
                        if tmp.message.is_none() {
         266  +
                            tmp.message = _error_message;
         267  +
                        }
         268  +
                        tmp
         269  +
                    })
         270  +
                }
         271  +
                "InvalidGrantTokenException" => {
         272  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::InvalidGrantTokenException({
         273  +
                        let mut tmp = match protocol
         274  +
                            .deserialize_response(response, crate::types::error::InvalidGrantTokenException::SCHEMA, _cfg)
         275  +
                            .and_then(|mut deser| {
         276  +
                                crate::types::error::InvalidGrantTokenException::deserialize_with_response(
         277  +
                                    &mut *deser,
         278  +
                                    response.headers(),
         279  +
                                    response.status().into(),
         280  +
                                    body,
         281  +
                                )
         282  +
                            }) {
         283  +
                            ::std::result::Result::Ok(val) => val,
         284  +
                            ::std::result::Result::Err(e) => {
         285  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         286  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         287  +
                                ))
         288  +
                            }
         289  +
                        };
         290  +
                        tmp.meta = generic;
         291  +
                        if tmp.message.is_none() {
         292  +
                            tmp.message = _error_message;
         293  +
                        }
         294  +
                        tmp
         295  +
                    })
         296  +
                }
         297  +
                "InvalidKeyUsageException" => {
         298  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::InvalidKeyUsageException({
         299  +
                        let mut tmp = match protocol
         300  +
                            .deserialize_response(response, crate::types::error::InvalidKeyUsageException::SCHEMA, _cfg)
         301  +
                            .and_then(|mut deser| {
         302  +
                                crate::types::error::InvalidKeyUsageException::deserialize_with_response(
         303  +
                                    &mut *deser,
         304  +
                                    response.headers(),
         305  +
                                    response.status().into(),
         306  +
                                    body,
         307  +
                                )
         308  +
                            }) {
         309  +
                            ::std::result::Result::Ok(val) => val,
         310  +
                            ::std::result::Result::Err(e) => {
         311  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         312  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         313  +
                                ))
         314  +
                            }
         315  +
                        };
         316  +
                        tmp.meta = generic;
         317  +
                        if tmp.message.is_none() {
         318  +
                            tmp.message = _error_message;
         319  +
                        }
         320  +
                        tmp
         321  +
                    })
         322  +
                }
         323  +
                "KeyUnavailableException" => {
         324  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::KeyUnavailableException({
         325  +
                        let mut tmp = match protocol
         326  +
                            .deserialize_response(response, crate::types::error::KeyUnavailableException::SCHEMA, _cfg)
         327  +
                            .and_then(|mut deser| {
         328  +
                                crate::types::error::KeyUnavailableException::deserialize_with_response(
         329  +
                                    &mut *deser,
         330  +
                                    response.headers(),
         331  +
                                    response.status().into(),
         332  +
                                    body,
         333  +
                                )
         334  +
                            }) {
         335  +
                            ::std::result::Result::Ok(val) => val,
         336  +
                            ::std::result::Result::Err(e) => {
         337  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         338  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         339  +
                                ))
         340  +
                            }
         341  +
                        };
         342  +
                        tmp.meta = generic;
         343  +
                        if tmp.message.is_none() {
         344  +
                            tmp.message = _error_message;
         345  +
                        }
         346  +
                        tmp
         347  +
                    })
         348  +
                }
         349  +
                "KMSInternalException" => {
         350  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::KmsInternalException({
         351  +
                        let mut tmp = match protocol
         352  +
                            .deserialize_response(response, crate::types::error::KmsInternalException::SCHEMA, _cfg)
         353  +
                            .and_then(|mut deser| {
         354  +
                                crate::types::error::KmsInternalException::deserialize_with_response(
         355  +
                                    &mut *deser,
         356  +
                                    response.headers(),
         357  +
                                    response.status().into(),
         358  +
                                    body,
         359  +
                                )
         360  +
                            }) {
         361  +
                            ::std::result::Result::Ok(val) => val,
         362  +
                            ::std::result::Result::Err(e) => {
         363  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         364  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         365  +
                                ))
         366  +
                            }
         367  +
                        };
         368  +
                        tmp.meta = generic;
         369  +
                        if tmp.message.is_none() {
         370  +
                            tmp.message = _error_message;
         371  +
                        }
         372  +
                        tmp
         373  +
                    })
         374  +
                }
         375  +
                "KMSInvalidStateException" => {
         376  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::KmsInvalidStateException({
         377  +
                        let mut tmp = match protocol
         378  +
                            .deserialize_response(response, crate::types::error::KmsInvalidStateException::SCHEMA, _cfg)
         379  +
                            .and_then(|mut deser| {
         380  +
                                crate::types::error::KmsInvalidStateException::deserialize_with_response(
         381  +
                                    &mut *deser,
         382  +
                                    response.headers(),
         383  +
                                    response.status().into(),
         384  +
                                    body,
         385  +
                                )
         386  +
                            }) {
         387  +
                            ::std::result::Result::Ok(val) => val,
         388  +
                            ::std::result::Result::Err(e) => {
         389  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         390  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         391  +
                                ))
         392  +
                            }
         393  +
                        };
         394  +
                        tmp.meta = generic;
         395  +
                        if tmp.message.is_none() {
         396  +
                            tmp.message = _error_message;
         397  +
                        }
         398  +
                        tmp
         399  +
                    })
         400  +
                }
         401  +
                "NotFoundException" => {
         402  +
                    crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::NotFoundException({
         403  +
                        let mut tmp = match protocol
         404  +
                            .deserialize_response(response, crate::types::error::NotFoundException::SCHEMA, _cfg)
         405  +
                            .and_then(|mut deser| {
         406  +
                                crate::types::error::NotFoundException::deserialize_with_response(
         407  +
                                    &mut *deser,
         408  +
                                    response.headers(),
         409  +
                                    response.status().into(),
         410  +
                                    body,
         411  +
                                )
         412  +
                            }) {
         413  +
                            ::std::result::Result::Ok(val) => val,
         414  +
                            ::std::result::Result::Err(e) => {
         415  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         416  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         417  +
                                ))
         418  +
                            }
         419  +
                        };
         420  +
                        tmp.meta = generic;
         421  +
                        if tmp.message.is_none() {
         422  +
                            tmp.message = _error_message;
         423  +
                        }
         424  +
                        tmp
         425  +
                    })
         426  +
                }
         427  +
                _ => crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextError::generic(generic),
         428  +
            };
         429  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         430  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         431  +
            ))
         432  +
        } else {
         433  +
            let protocol = _cfg
         434  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         435  +
                .expect("a SharedClientProtocol is required");
         436  +
            let mut deser = protocol
         437  +
                .deserialize_response(response, GenerateDataKeyWithoutPlaintext::OUTPUT_SCHEMA, _cfg)
         438  +
                .map_err(|e| {
         439  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         440  +
                })?;
         441  +
            let body = response.body().bytes().expect("body loaded");
         442  +
            let output = crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextOutput::deserialize_with_response(
         443  +
                &mut *deser,
         444  +
                response.headers(),
         445  +
                response.status().into(),
         446  +
                body,
         447  +
            )
         448  +
            .map_err(|e| {
         449  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         450  +
            })?;
         451  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         452  +
        }
  172    453   
    }
  173    454   
}
  174    455   
#[derive(Debug)]
  175    456   
struct GenerateDataKeyWithoutPlaintextRequestSerializer;
  176    457   
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for GenerateDataKeyWithoutPlaintextRequestSerializer {
  177    458   
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
  178    459   
    fn serialize_input(
  179    460   
        &self,
  180    461   
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
  181    462   
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
  182    463   
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
  183    464   
        let input = input
  184    465   
            .downcast::<crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextInput>()
  185    466   
            .expect("correct type");
  186         -
        let _header_serialization_settings = _cfg
  187         -
            .load::<crate::serialization_settings::HeaderSerializationSettings>()
  188         -
            .cloned()
  189         -
            .unwrap_or_default();
  190         -
        let mut request_builder = {
  191         -
            #[allow(clippy::uninlined_format_args)]
  192         -
            fn uri_base(
  193         -
                _input: &crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextInput,
  194         -
                output: &mut ::std::string::String,
  195         -
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  196         -
                use ::std::fmt::Write as _;
  197         -
                ::std::write!(output, "/").expect("formatting should succeed");
  198         -
                ::std::result::Result::Ok(())
  199         -
            }
  200         -
            #[allow(clippy::unnecessary_wraps)]
  201         -
            fn update_http_builder(
  202         -
                input: &crate::operation::generate_data_key_without_plaintext::GenerateDataKeyWithoutPlaintextInput,
  203         -
                builder: ::http_1x::request::Builder,
  204         -
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  205         -
                let mut uri = ::std::string::String::new();
  206         -
                uri_base(input, &mut uri)?;
  207         -
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  208         -
            }
  209         -
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  210         -
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
  211         -
            builder = _header_serialization_settings.set_default_header(
  212         -
                builder,
  213         -
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  214         -
                "TrentService.GenerateDataKeyWithoutPlaintext",
  215         -
            );
  216         -
            builder
  217         -
        };
  218         -
        let body = ::aws_smithy_types::body::SdkBody::from(
  219         -
            crate::protocol_serde::shape_generate_data_key_without_plaintext::ser_generate_data_key_without_plaintext_input(&input)?,
  220         -
        );
  221         -
        if let Some(content_length) = body.content_length() {
  222         -
            let content_length = content_length.to_string();
  223         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  224         -
        }
  225         -
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
         467  +
        let protocol = _cfg
         468  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         469  +
            .expect("a SharedClientProtocol is required");
         470  +
        let mut request = protocol
         471  +
            .serialize_request(&input, GenerateDataKeyWithoutPlaintext::INPUT_SCHEMA, "", _cfg)
         472  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         473  +
         474  +
        return ::std::result::Result::Ok(request);
  226    475   
    }
  227    476   
}
  228    477   
#[derive(Debug)]
  229    478   
struct GenerateDataKeyWithoutPlaintextEndpointParamsInterceptor;
  230    479   
  231    480   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for GenerateDataKeyWithoutPlaintextEndpointParamsInterceptor {
  232    481   
    fn name(&self) -> &'static str {
  233    482   
        "GenerateDataKeyWithoutPlaintextEndpointParamsInterceptor"
  234    483   
    }
  235    484