AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405

Files changed:

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/get_speech_synthesis_task.rs

@@ -176,176 +242,242 @@
  196    196   
                        "task_id",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/v1/synthesisTasks/{TaskId}", TaskId = task_id).expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::get_speech_synthesis_task::GetSpeechSynthesisTaskInput,
  206         -
                builder: ::http::request::Builder,
  207         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         206  +
                builder: ::http_1x::request::Builder,
         207  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  208    208   
                let mut uri = ::std::string::String::new();
  209    209   
                uri_base(input, &mut uri)?;
  210    210   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  211    211   
            }
  212         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         212  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  213    213   
            builder
  214    214   
        };
  215    215   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  216    216   
  217    217   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  218    218   
    }
  219    219   
}
  220    220   
#[derive(Debug)]
  221    221   
struct GetSpeechSynthesisTaskEndpointParamsInterceptor;
  222    222   

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/list_lexicons.rs

@@ -174,174 +241,241 @@
  194    194   
                if let ::std::option::Option::Some(inner_1) = &_input.next_token {
  195    195   
                    {
  196    196   
                        query.push_kv("NextToken", &::aws_smithy_http::query::fmt_string(inner_1));
  197    197   
                    }
  198    198   
                }
  199    199   
                ::std::result::Result::Ok(())
  200    200   
            }
  201    201   
            #[allow(clippy::unnecessary_wraps)]
  202    202   
            fn update_http_builder(
  203    203   
                input: &crate::operation::list_lexicons::ListLexiconsInput,
  204         -
                builder: ::http::request::Builder,
  205         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         204  +
                builder: ::http_1x::request::Builder,
         205  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  206    206   
                let mut uri = ::std::string::String::new();
  207    207   
                uri_base(input, &mut uri)?;
  208    208   
                uri_query(input, &mut uri)?;
  209    209   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  210    210   
            }
  211         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         211  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  212    212   
            builder
  213    213   
        };
  214    214   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  215    215   
  216    216   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  217    217   
    }
  218    218   
}
  219    219   
#[derive(Debug)]
  220    220   
struct ListLexiconsEndpointParamsInterceptor;
  221    221   

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/list_speech_synthesis_tasks.rs

@@ -187,187 +254,254 @@
  207    207   
                if let ::std::option::Option::Some(inner_3) = &_input.status {
  208    208   
                    {
  209    209   
                        query.push_kv("Status", &::aws_smithy_http::query::fmt_string(inner_3));
  210    210   
                    }
  211    211   
                }
  212    212   
                ::std::result::Result::Ok(())
  213    213   
            }
  214    214   
            #[allow(clippy::unnecessary_wraps)]
  215    215   
            fn update_http_builder(
  216    216   
                input: &crate::operation::list_speech_synthesis_tasks::ListSpeechSynthesisTasksInput,
  217         -
                builder: ::http::request::Builder,
  218         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         217  +
                builder: ::http_1x::request::Builder,
         218  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  219    219   
                let mut uri = ::std::string::String::new();
  220    220   
                uri_base(input, &mut uri)?;
  221    221   
                uri_query(input, &mut uri)?;
  222    222   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  223    223   
            }
  224         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         224  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  225    225   
            builder
  226    226   
        };
  227    227   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  228    228   
  229    229   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  230    230   
    }
  231    231   
}
  232    232   
#[derive(Debug)]
  233    233   
struct ListSpeechSynthesisTasksEndpointParamsInterceptor;
  234    234   

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/put_lexicon.rs

@@ -171,171 +244,244 @@
  191    191   
                        "name",
  192    192   
                        "cannot be empty or unset",
  193    193   
                    ));
  194    194   
                }
  195    195   
                ::std::write!(output, "/v1/lexicons/{Name}", Name = name).expect("formatting should succeed");
  196    196   
                ::std::result::Result::Ok(())
  197    197   
            }
  198    198   
            #[allow(clippy::unnecessary_wraps)]
  199    199   
            fn update_http_builder(
  200    200   
                input: &crate::operation::put_lexicon::PutLexiconInput,
  201         -
                builder: ::http::request::Builder,
  202         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         201  +
                builder: ::http_1x::request::Builder,
         202  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  203    203   
                let mut uri = ::std::string::String::new();
  204    204   
                uri_base(input, &mut uri)?;
  205    205   
                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
  206    206   
            }
  207         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  208         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         207  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         208  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  209    209   
            builder
  210    210   
        };
  211    211   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_put_lexicon::ser_put_lexicon_input(&input)?);
  212    212   
        if let Some(content_length) = body.content_length() {
  213    213   
            let content_length = content_length.to_string();
  214         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         214  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  215    215   
        }
  216    216   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  217    217   
    }
  218    218   
}
  219    219   
#[derive(Debug)]
  220    220   
struct PutLexiconEndpointParamsInterceptor;
  221    221   
  222    222   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for PutLexiconEndpointParamsInterceptor {
  223    223   
    fn name(&self) -> &'static str {
  224    224   
        "PutLexiconEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/start_speech_synthesis_task.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/v1/synthesisTasks").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::start_speech_synthesis_task::StartSpeechSynthesisTaskInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(
  206    206   
            crate::protocol_serde::shape_start_speech_synthesis_task::ser_start_speech_synthesis_task_input(&input)?,
  207    207   
        );
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct StartSpeechSynthesisTaskEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartSpeechSynthesisTaskEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "StartSpeechSynthesisTaskEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/polly/src/operation/synthesize_speech.rs

@@ -174,174 +247,247 @@
  194    194   
                _input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
  195    195   
                output: &mut ::std::string::String,
  196    196   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                use ::std::fmt::Write as _;
  198    198   
                ::std::write!(output, "/v1/speech").expect("formatting should succeed");
  199    199   
                ::std::result::Result::Ok(())
  200    200   
            }
  201    201   
            #[allow(clippy::unnecessary_wraps)]
  202    202   
            fn update_http_builder(
  203    203   
                input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
  204         -
                builder: ::http::request::Builder,
  205         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         204  +
                builder: ::http_1x::request::Builder,
         205  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  206    206   
                let mut uri = ::std::string::String::new();
  207    207   
                uri_base(input, &mut uri)?;
  208    208   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  209    209   
            }
  210         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  211         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         210  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         211  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  212    212   
            builder
  213    213   
        };
  214    214   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_synthesize_speech::ser_synthesize_speech_input(&input)?);
  215    215   
        if let Some(content_length) = body.content_length() {
  216    216   
            let content_length = content_length.to_string();
  217         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         217  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  218    218   
        }
  219    219   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  220    220   
    }
  221    221   
}
  222    222   
#[derive(Debug)]
  223    223   
struct SynthesizeSpeechEndpointParamsInterceptor;
  224    224   
  225    225   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SynthesizeSpeechEndpointParamsInterceptor {
  226    226   
    fn name(&self) -> &'static str {
  227    227   
        "SynthesizeSpeechEndpointParamsInterceptor"
@@ -519,519 +563,563 @@
  539    539   
                let inner_11 = &_input.voice_id;
  540    540   
                let inner_11 = inner_11
  541    541   
                    .as_ref()
  542    542   
                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("voice_id", "cannot be empty or unset"))?;
  543    543   
                query.push_kv("VoiceId", &::aws_smithy_http::query::fmt_string(inner_11));
  544    544   
                ::std::result::Result::Ok(())
  545    545   
            }
  546    546   
            #[allow(clippy::unnecessary_wraps)]
  547    547   
            fn update_http_builder(
  548    548   
                input: &crate::operation::synthesize_speech::SynthesizeSpeechInput,
  549         -
                builder: ::http::request::Builder,
  550         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         549  +
                builder: ::http_1x::request::Builder,
         550  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  551    551   
                let mut uri = ::std::string::String::new();
  552    552   
                uri_base(input, &mut uri)?;
  553    553   
                uri_query(input, &mut uri)?;
  554    554   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  555    555   
            }
  556         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         556  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  557    557   
            builder
  558    558   
        };
  559    559   
        let body = ::aws_smithy_types::body::SdkBody::empty();
  560    560   
  561    561   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  562    562   
    }
  563    563   
}

tmp-codegen-diff/aws-sdk/sdk/polly/src/presigning.rs

@@ -173,173 +273,271 @@
  193    193   
    }
  194    194   
}
  195    195   
  196    196   
impl PresignedRequest {
  197    197   
    #[allow(dead_code)]
  198    198   
    pub(crate) fn new(inner: HttpRequest) -> Result<Self, BoxError> {
  199    199   
        // throw out the body so we're sure it's cloneable
  200    200   
        let http_request = inner.map(|_body| SdkBody::empty());
  201    201   
        // this should never fail, a presigned request should always be convertible, but better to
  202    202   
        // protect against this potential panic
  203         -
        let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http02x()?;
         203  +
        let _ = http_request.try_clone().expect("must be cloneable, body is empty").try_into_http1x()?;
  204    204   
        Ok(Self { http_request })
  205    205   
    }
  206    206   
  207    207   
    /// Returns the HTTP request method.
  208    208   
    pub fn method(&self) -> &str {
  209    209   
        self.http_request.method()
  210    210   
    }
  211    211   
  212    212   
    /// Returns the HTTP request URI.
  213    213   
    pub fn uri(&self) -> &str {
  214    214   
        self.http_request.uri()
  215    215   
    }
  216    216   
  217    217   
    /// Returns any HTTP headers that need to go along with the request, except for `Host`,
  218    218   
    /// which should be sent based on the endpoint in the URI by the HTTP client rather than
  219    219   
    /// added directly.
  220    220   
    pub fn headers(&self) -> impl Iterator<Item = (&str, &str)> {
  221    221   
        self.http_request.headers().iter()
  222    222   
    }
  223    223   
  224    224   
    /// Given a body, produce an `http::Request` from this `PresignedRequest`
  225    225   
    #[deprecated = "Prefer the `make_http_1x_request()` instead by enabling the `http-1x` feature."]
  226    226   
    #[allow(deprecated)]
  227    227   
    pub fn make_http_02x_request<B>(&self, body: B) -> http::Request<B> {
  228    228   
        self.clone().into_http_02x_request(body)
  229    229   
    }
  230    230   
  231    231   
    /// Converts this `PresignedRequest` directly into an `http` request.
  232    232   
    #[deprecated = "Prefer the `into_http_1x_request` instead by enabling the `http-1x` feature."]
  233    233   
    pub fn into_http_02x_request<B>(self, body: B) -> http::Request<B> {
  234    234   
        self.http_request
  235    235   
            .try_into_http02x()
  236    236   
            .expect("constructor validated convertibility")
  237    237   
            .map(|_req| body)
  238    238   
    }
  239    239   
  240         -
    #[cfg(feature = "http-1x")]
  241    240   
    /// Given a body, produce an `http_1x::Request` from this `PresignedRequest`
  242    241   
    pub fn make_http_1x_request<B>(&self, body: B) -> http_1x::Request<B> {
  243    242   
        self.clone().into_http_1x_request(body)
  244    243   
    }
  245    244   
  246         -
    #[cfg(feature = "http-1x")]
  247    245   
    /// Converts this `PresignedRequest` directly into an `http_1x` request.
  248    246   
    pub fn into_http_1x_request<B>(self, body: B) -> http_1x::Request<B> {
  249    247   
        self.http_request
  250    248   
            .try_into_http1x()
  251    249   
            .expect("constructor validated convertibility")
  252    250   
            .map(|_req| body)
  253    251   
    }
  254    252   
}
  255    253   
  256    254   
impl fmt::Debug for PresignedRequest {

tmp-codegen-diff/aws-sdk/sdk/polly/src/serialization_settings.rs

@@ -1,1 +78,83 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
/*
    3      3   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
    4      4   
 * SPDX-License-Identifier: Apache-2.0
    5      5   
 */
    6      6   
    7      7   
#![allow(dead_code)]
    8      8   
    9      9   
use aws_smithy_http::header::set_request_header_if_absent;
   10     10   
use aws_smithy_types::config_bag::{Storable, StoreReplace};
   11         -
use http::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
          11  +
use http_1x::header::{HeaderName, CONTENT_LENGTH, CONTENT_TYPE};
   12     12   
   13     13   
/// Configuration for how default protocol headers are serialized
   14     14   
#[derive(Clone, Debug, Default)]
   15     15   
pub(crate) struct HeaderSerializationSettings {
   16     16   
    omit_default_content_length: bool,
   17     17   
    omit_default_content_type: bool,
   18     18   
}
   19     19   
   20     20   
impl HeaderSerializationSettings {
   21     21   
    /// Creates new [`HeaderSerializationSettings`]
   22     22   
    pub(crate) fn new() -> Self {
   23     23   
        Default::default()
   24     24   
    }
   25     25   
   26     26   
    /// Omit the default `Content-Length` header during serialization
   27     27   
    pub(crate) fn omit_default_content_length(self) -> Self {
   28     28   
        Self {
   29     29   
            omit_default_content_length: true,
   30     30   
            ..self
   31     31   
        }
   32     32   
    }
   33     33   
   34     34   
    /// Omit the default `Content-Type` header during serialization
   35     35   
    pub(crate) fn omit_default_content_type(self) -> Self {
   36     36   
        Self {
   37     37   
            omit_default_content_type: true,
   38     38   
            ..self
   39     39   
        }
   40     40   
    }
   41     41   
   42     42   
    /// Returns true if the given default header name should be serialized
   43     43   
    fn include_header(&self, header: &HeaderName) -> bool {
   44     44   
        (!self.omit_default_content_length || header != CONTENT_LENGTH) && (!self.omit_default_content_type || header != CONTENT_TYPE)
   45     45   
    }
   46     46   
   47     47   
    /// Sets a default header on the given request builder if it should be serialized
   48         -
    pub(crate) fn set_default_header(&self, mut request: http::request::Builder, header_name: HeaderName, value: &str) -> http::request::Builder {
          48  +
    pub(crate) fn set_default_header(
          49  +
        &self,
          50  +
        mut request: http_1x::request::Builder,
          51  +
        header_name: HeaderName,
          52  +
        value: &str,
          53  +
    ) -> http_1x::request::Builder {
   49     54   
        if self.include_header(&header_name) {
   50     55   
            request = set_request_header_if_absent(request, header_name, value);
   51     56   
        }
   52     57   
        request
   53     58   
    }
   54     59   
}
   55     60   
   56     61   
impl Storable for HeaderSerializationSettings {
   57     62   
    type Storer = StoreReplace<Self>;
   58     63   
}

tmp-codegen-diff/aws-sdk/sdk/route53/Cargo.toml

@@ -1,1 +110,115 @@
   14     14   
protocol = "aws.protocols#restXml"
   15     15   
[package.metadata.docs.rs]
   16     16   
all-features = true
   17     17   
targets = ["x86_64-unknown-linux-gnu"]
   18     18   
[dependencies.aws-credential-types]
   19     19   
path = "../aws-credential-types"
   20     20   
version = "1.2.11"
   21     21   
   22     22   
[dependencies.aws-runtime]
   23     23   
path = "../aws-runtime"
   24         -
version = "1.5.18"
          24  +
version = "1.6.0"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28         -
version = "1.2.7"
          28  +
version = "1.2.8"
   29     29   
   30     30   
[dependencies.aws-smithy-http]
   31     31   
path = "../aws-smithy-http"
   32         -
version = "0.62.6"
          32  +
version = "0.63.0"
   33     33   
   34     34   
[dependencies.aws-smithy-json]
   35     35   
path = "../aws-smithy-json"
   36         -
version = "0.61.9"
          36  +
version = "0.62.0"
   37     37   
   38     38   
[dependencies.aws-smithy-observability]
   39     39   
path = "../aws-smithy-observability"
   40         -
version = "0.2.0"
          40  +
version = "0.2.1"
   41     41   
   42     42   
[dependencies.aws-smithy-runtime]
   43     43   
path = "../aws-smithy-runtime"
   44     44   
features = ["client"]
   45         -
version = "1.9.8"
          45  +
version = "1.10.0"
   46     46   
   47     47   
[dependencies.aws-smithy-runtime-api]
   48     48   
path = "../aws-smithy-runtime-api"
   49         -
features = ["client", "http-02x"]
   50         -
version = "1.10.0"
          49  +
features = ["client", "http-1x"]
          50  +
version = "1.11.0"
   51     51   
   52     52   
[dependencies.aws-smithy-types]
   53     53   
path = "../aws-smithy-types"
   54         -
version = "1.3.6"
          54  +
features = ["http-body-1-x"]
          55  +
version = "1.4.0"
   55     56   
   56     57   
[dependencies.aws-smithy-xml]
   57     58   
path = "../aws-smithy-xml"
   58     59   
version = "0.60.13"
   59     60   
   60     61   
[dependencies.aws-types]
   61     62   
path = "../aws-types"
   62     63   
version = "1.3.11"
   63     64   
   64     65   
[dependencies.fastrand]
   65     66   
version = "2.0.0"
   66     67   
   67     68   
[dependencies.http]
   68     69   
version = "0.2.9"
   69     70   
          71  +
[dependencies.http-1x]
          72  +
version = "1"
          73  +
package = "http"
          74  +
   70     75   
[dependencies.regex-lite]
   71     76   
version = "0.1.5"
   72     77   
   73     78   
[dependencies.tracing]
   74     79   
version = "0.1"
   75     80   
[dev-dependencies.aws-config]
   76     81   
path = "../aws-config"
   77     82   
version = "1.8.12"
   78     83   
   79     84   
[dev-dependencies.aws-credential-types]
   80     85   
path = "../aws-credential-types"
   81     86   
features = ["test-util"]
   82     87   
version = "1.2.11"
   83     88   
   84     89   
[dev-dependencies.aws-smithy-http-client]
   85     90   
path = "../aws-smithy-http-client"
   86     91   
features = ["test-util"]
   87         -
version = "1.1.5"
          92  +
version = "1.1.6"
   88     93   
   89     94   
[dev-dependencies.pretty_assertions]
   90     95   
version = "1.3.0"
   91     96   
   92     97   
[dev-dependencies.proptest]
   93     98   
version = "1"
   94     99   
   95    100   
[dev-dependencies.tokio]
   96    101   
version = "1.23.1"
   97    102   
features = ["macros", "test-util", "rt-multi-thread"]

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/activate_key_signing_key.rs

@@ -196,196 +262,262 @@
  216    216   
                    "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate",
  217    217   
                    HostedZoneId = hosted_zone_id,
  218    218   
                    Name = name
  219    219   
                )
  220    220   
                .expect("formatting should succeed");
  221    221   
                ::std::result::Result::Ok(())
  222    222   
            }
  223    223   
            #[allow(clippy::unnecessary_wraps)]
  224    224   
            fn update_http_builder(
  225    225   
                input: &crate::operation::activate_key_signing_key::ActivateKeySigningKeyInput,
  226         -
                builder: ::http::request::Builder,
  227         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         226  +
                builder: ::http_1x::request::Builder,
         227  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  228    228   
                let mut uri = ::std::string::String::new();
  229    229   
                uri_base(input, &mut uri)?;
  230    230   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  231    231   
            }
  232         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  233    233   
            builder
  234    234   
        };
  235    235   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  236    236   
  237    237   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  238    238   
    }
  239    239   
}
  240    240   
#[derive(Debug)]
  241    241   
struct ActivateKeySigningKeyEndpointParamsInterceptor;
  242    242   

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/associate_vpc_with_hosted_zone.rs

@@ -190,190 +265,265 @@
  210    210   
                    output,
  211    211   
                    "/2013-04-01/hostedzone/{HostedZoneId}/associatevpc",
  212    212   
                    HostedZoneId = hosted_zone_id
  213    213   
                )
  214    214   
                .expect("formatting should succeed");
  215    215   
                ::std::result::Result::Ok(())
  216    216   
            }
  217    217   
            #[allow(clippy::unnecessary_wraps)]
  218    218   
            fn update_http_builder(
  219    219   
                input: &crate::operation::associate_vpc_with_hosted_zone::AssociateVpcWithHostedZoneInput,
  220         -
                builder: ::http::request::Builder,
  221         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         220  +
                builder: ::http_1x::request::Builder,
         221  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  222    222   
                let mut uri = ::std::string::String::new();
  223    223   
                uri_base(input, &mut uri)?;
  224    224   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  225    225   
            }
  226         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  227         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         226  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         227  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  228    228   
            builder
  229    229   
        };
  230    230   
        let body = ::aws_smithy_types::body::SdkBody::from(
  231    231   
            crate::protocol_serde::shape_associate_vpc_with_hosted_zone::ser_associate_vpc_with_hosted_zone_op_input(&input)?,
  232    232   
        );
  233    233   
        if let Some(content_length) = body.content_length() {
  234    234   
            let content_length = content_length.to_string();
  235         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         235  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  236    236   
        }
  237    237   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  238    238   
    }
  239    239   
}
  240    240   
#[derive(Debug)]
  241    241   
struct AssociateVPCWithHostedZoneEndpointParamsInterceptor;
  242    242   
  243    243   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AssociateVPCWithHostedZoneEndpointParamsInterceptor {
  244    244   
    fn name(&self) -> &'static str {
  245    245   
        "AssociateVPCWithHostedZoneEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_cidr_collection.rs

@@ -176,176 +251,251 @@
  196    196   
                        "id",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/2013-04-01/cidrcollection/{Id}", Id = id).expect("formatting should succeed");
  201    201   
                ::std::result::Result::Ok(())
  202    202   
            }
  203    203   
            #[allow(clippy::unnecessary_wraps)]
  204    204   
            fn update_http_builder(
  205    205   
                input: &crate::operation::change_cidr_collection::ChangeCidrCollectionInput,
  206         -
                builder: ::http::request::Builder,
  207         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         206  +
                builder: ::http_1x::request::Builder,
         207  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  208    208   
                let mut uri = ::std::string::String::new();
  209    209   
                uri_base(input, &mut uri)?;
  210    210   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  211    211   
            }
  212         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  213         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         212  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         213  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_change_cidr_collection::ser_change_cidr_collection_op_input(
  217    217   
            &input,
  218    218   
        )?);
  219    219   
        if let Some(content_length) = body.content_length() {
  220    220   
            let content_length = content_length.to_string();
  221         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         221  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  222    222   
        }
  223    223   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  224    224   
    }
  225    225   
}
  226    226   
#[derive(Debug)]
  227    227   
struct ChangeCidrCollectionEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeCidrCollectionEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "ChangeCidrCollectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_resource_record_sets.rs

@@ -180,180 +255,255 @@
  200    200   
                        "cannot be empty or unset",
  201    201   
                    ));
  202    202   
                }
  203    203   
                ::std::write!(output, "/2013-04-01/hostedzone/{HostedZoneId}/rrset", HostedZoneId = hosted_zone_id)
  204    204   
                    .expect("formatting should succeed");
  205    205   
                ::std::result::Result::Ok(())
  206    206   
            }
  207    207   
            #[allow(clippy::unnecessary_wraps)]
  208    208   
            fn update_http_builder(
  209    209   
                input: &crate::operation::change_resource_record_sets::ChangeResourceRecordSetsInput,
  210         -
                builder: ::http::request::Builder,
  211         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         210  +
                builder: ::http_1x::request::Builder,
         211  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  212    212   
                let mut uri = ::std::string::String::new();
  213    213   
                uri_base(input, &mut uri)?;
  214    214   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  215    215   
            }
  216         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  217         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         216  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         217  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  218    218   
            builder
  219    219   
        };
  220    220   
        let body = ::aws_smithy_types::body::SdkBody::from(
  221    221   
            crate::protocol_serde::shape_change_resource_record_sets::ser_change_resource_record_sets_op_input(&input)?,
  222    222   
        );
  223    223   
        if let Some(content_length) = body.content_length() {
  224    224   
            let content_length = content_length.to_string();
  225         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         225  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  226    226   
        }
  227    227   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  228    228   
    }
  229    229   
}
  230    230   
#[derive(Debug)]
  231    231   
struct ChangeResourceRecordSetsEndpointParamsInterceptor;
  232    232   
  233    233   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeResourceRecordSetsEndpointParamsInterceptor {
  234    234   
    fn name(&self) -> &'static str {
  235    235   
        "ChangeResourceRecordSetsEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/change_tags_for_resource.rs

@@ -193,193 +268,268 @@
  213    213   
                    "/2013-04-01/tags/{ResourceType}/{ResourceId}",
  214    214   
                    ResourceType = resource_type,
  215    215   
                    ResourceId = resource_id
  216    216   
                )
  217    217   
                .expect("formatting should succeed");
  218    218   
                ::std::result::Result::Ok(())
  219    219   
            }
  220    220   
            #[allow(clippy::unnecessary_wraps)]
  221    221   
            fn update_http_builder(
  222    222   
                input: &crate::operation::change_tags_for_resource::ChangeTagsForResourceInput,
  223         -
                builder: ::http::request::Builder,
  224         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         223  +
                builder: ::http_1x::request::Builder,
         224  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  225    225   
                let mut uri = ::std::string::String::new();
  226    226   
                uri_base(input, &mut uri)?;
  227    227   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  228    228   
            }
  229         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  230         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         229  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         230  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  231    231   
            builder
  232    232   
        };
  233    233   
        let body = ::aws_smithy_types::body::SdkBody::from(
  234    234   
            crate::protocol_serde::shape_change_tags_for_resource::ser_change_tags_for_resource_op_input(&input)?,
  235    235   
        );
  236    236   
        if let Some(content_length) = body.content_length() {
  237    237   
            let content_length = content_length.to_string();
  238         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         238  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  239    239   
        }
  240    240   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  241    241   
    }
  242    242   
}
  243    243   
#[derive(Debug)]
  244    244   
struct ChangeTagsForResourceEndpointParamsInterceptor;
  245    245   
  246    246   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ChangeTagsForResourceEndpointParamsInterceptor {
  247    247   
    fn name(&self) -> &'static str {
  248    248   
        "ChangeTagsForResourceEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_cidr_collection.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_cidr_collection::CreateCidrCollectionInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/cidrcollection").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_cidr_collection::CreateCidrCollectionInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_cidr_collection::ser_create_cidr_collection_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateCidrCollectionEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateCidrCollectionEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateCidrCollectionEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/route53/src/operation/create_health_check.rs

@@ -165,165 +240,240 @@
  185    185   
                _input: &crate::operation::create_health_check::CreateHealthCheckInput,
  186    186   
                output: &mut ::std::string::String,
  187    187   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  188    188   
                use ::std::fmt::Write as _;
  189    189   
                ::std::write!(output, "/2013-04-01/healthcheck").expect("formatting should succeed");
  190    190   
                ::std::result::Result::Ok(())
  191    191   
            }
  192    192   
            #[allow(clippy::unnecessary_wraps)]
  193    193   
            fn update_http_builder(
  194    194   
                input: &crate::operation::create_health_check::CreateHealthCheckInput,
  195         -
                builder: ::http::request::Builder,
  196         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         195  +
                builder: ::http_1x::request::Builder,
         196  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  197    197   
                let mut uri = ::std::string::String::new();
  198    198   
                uri_base(input, &mut uri)?;
  199    199   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  200    200   
            }
  201         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  202         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/xml");
         201  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         202  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/xml");
  203    203   
            builder
  204    204   
        };
  205    205   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_health_check::ser_create_health_check_op_input(
  206    206   
            &input,
  207    207   
        )?);
  208    208   
        if let Some(content_length) = body.content_length() {
  209    209   
            let content_length = content_length.to_string();
  210         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         210  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  211    211   
        }
  212    212   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  213    213   
    }
  214    214   
}
  215    215   
#[derive(Debug)]
  216    216   
struct CreateHealthCheckEndpointParamsInterceptor;
  217    217   
  218    218   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateHealthCheckEndpointParamsInterceptor {
  219    219   
    fn name(&self) -> &'static str {
  220    220   
        "CreateHealthCheckEndpointParamsInterceptor"