AWS SDK

AWS SDK

rev. 03e6e47f15dfd569240d570d98975ebba692c405 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_invoke_model.rs

@@ -178,178 +277,277 @@
  198    198   
        );
  199    199   
        output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
  200    200   
        crate::serde_util::invoke_model_output_output_correct_errors(output)
  201    201   
            .build()
  202    202   
            .map_err(crate::operation::invoke_model::InvokeModelError::unhandled)?
  203    203   
    })
  204    204   
}
  205    205   
  206    206   
pub fn ser_invoke_model_headers(
  207    207   
    input: &crate::operation::invoke_model::InvokeModelInput,
  208         -
    mut builder: ::http::request::Builder,
  209         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         208  +
    mut builder: ::http_1x::request::Builder,
         209  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  210    210   
    if let ::std::option::Option::Some(inner_1) = &input.content_type {
  211    211   
        let formatted_2 = inner_1.as_str();
  212    212   
        let header_value = formatted_2;
  213         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         213  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  214    214   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  215    215   
                "content_type",
  216    216   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  217    217   
            )
  218    218   
        })?;
  219    219   
        builder = builder.header("Content-Type", header_value);
  220    220   
    }
  221    221   
    if let ::std::option::Option::Some(inner_3) = &input.accept {
  222    222   
        let formatted_4 = inner_3.as_str();
  223    223   
        let header_value = formatted_4;
  224         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         224  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  225    225   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  226    226   
                "accept",
  227    227   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  228    228   
            )
  229    229   
        })?;
  230    230   
        builder = builder.header("Accept", header_value);
  231    231   
    }
  232    232   
    if let ::std::option::Option::Some(inner_5) = &input.trace {
  233    233   
        let formatted_6 = inner_5.as_str();
  234    234   
        let header_value = formatted_6;
  235         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         235  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  236    236   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  237    237   
                "trace",
  238    238   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  239    239   
            )
  240    240   
        })?;
  241    241   
        builder = builder.header("X-Amzn-Bedrock-Trace", header_value);
  242    242   
    }
  243    243   
    if let ::std::option::Option::Some(inner_7) = &input.guardrail_identifier {
  244    244   
        let formatted_8 = inner_7.as_str();
  245    245   
        let header_value = formatted_8;
  246         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         246  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  247    247   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  248    248   
                "guardrail_identifier",
  249    249   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  250    250   
            )
  251    251   
        })?;
  252    252   
        builder = builder.header("X-Amzn-Bedrock-GuardrailIdentifier", header_value);
  253    253   
    }
  254    254   
    if let ::std::option::Option::Some(inner_9) = &input.guardrail_version {
  255    255   
        let formatted_10 = inner_9.as_str();
  256    256   
        let header_value = formatted_10;
  257         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         257  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  258    258   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  259    259   
                "guardrail_version",
  260    260   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  261    261   
            )
  262    262   
        })?;
  263    263   
        builder = builder.header("X-Amzn-Bedrock-GuardrailVersion", header_value);
  264    264   
    }
  265    265   
    if let ::std::option::Option::Some(inner_11) = &input.performance_config_latency {
  266    266   
        let formatted_12 = inner_11.as_str();
  267    267   
        let header_value = formatted_12;
  268         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         268  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  269    269   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  270    270   
                "performance_config_latency",
  271    271   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  272    272   
            )
  273    273   
        })?;
  274    274   
        builder = builder.header("X-Amzn-Bedrock-PerformanceConfig-Latency", header_value);
  275    275   
    }
  276    276   
    Ok(builder)
  277    277   
}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/protocol_serde/shape_invoke_model_with_response_stream.rs

@@ -224,224 +323,323 @@
  244    244   
                tmp.message = _error_message;
  245    245   
            }
  246    246   
            tmp
  247    247   
        }),
  248    248   
        _ => crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamError::generic(generic),
  249    249   
    })
  250    250   
}
  251    251   
  252    252   
pub fn ser_invoke_model_with_response_stream_headers(
  253    253   
    input: &crate::operation::invoke_model_with_response_stream::InvokeModelWithResponseStreamInput,
  254         -
    mut builder: ::http::request::Builder,
  255         -
) -> std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         254  +
    mut builder: ::http_1x::request::Builder,
         255  +
) -> std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  256    256   
    if let ::std::option::Option::Some(inner_1) = &input.content_type {
  257    257   
        let formatted_2 = inner_1.as_str();
  258    258   
        let header_value = formatted_2;
  259         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         259  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  260    260   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  261    261   
                "content_type",
  262    262   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  263    263   
            )
  264    264   
        })?;
  265    265   
        builder = builder.header("Content-Type", header_value);
  266    266   
    }
  267    267   
    if let ::std::option::Option::Some(inner_3) = &input.accept {
  268    268   
        let formatted_4 = inner_3.as_str();
  269    269   
        let header_value = formatted_4;
  270         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         270  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  271    271   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  272    272   
                "accept",
  273    273   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  274    274   
            )
  275    275   
        })?;
  276    276   
        builder = builder.header("X-Amzn-Bedrock-Accept", header_value);
  277    277   
    }
  278    278   
    if let ::std::option::Option::Some(inner_5) = &input.trace {
  279    279   
        let formatted_6 = inner_5.as_str();
  280    280   
        let header_value = formatted_6;
  281         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         281  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  282    282   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  283    283   
                "trace",
  284    284   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  285    285   
            )
  286    286   
        })?;
  287    287   
        builder = builder.header("X-Amzn-Bedrock-Trace", header_value);
  288    288   
    }
  289    289   
    if let ::std::option::Option::Some(inner_7) = &input.guardrail_identifier {
  290    290   
        let formatted_8 = inner_7.as_str();
  291    291   
        let header_value = formatted_8;
  292         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         292  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  293    293   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  294    294   
                "guardrail_identifier",
  295    295   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  296    296   
            )
  297    297   
        })?;
  298    298   
        builder = builder.header("X-Amzn-Bedrock-GuardrailIdentifier", header_value);
  299    299   
    }
  300    300   
    if let ::std::option::Option::Some(inner_9) = &input.guardrail_version {
  301    301   
        let formatted_10 = inner_9.as_str();
  302    302   
        let header_value = formatted_10;
  303         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         303  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  304    304   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  305    305   
                "guardrail_version",
  306    306   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  307    307   
            )
  308    308   
        })?;
  309    309   
        builder = builder.header("X-Amzn-Bedrock-GuardrailVersion", header_value);
  310    310   
    }
  311    311   
    if let ::std::option::Option::Some(inner_11) = &input.performance_config_latency {
  312    312   
        let formatted_12 = inner_11.as_str();
  313    313   
        let header_value = formatted_12;
  314         -
        let header_value: ::http::HeaderValue = header_value.parse().map_err(|err| {
         314  +
        let header_value: ::http_1x::HeaderValue = header_value.parse().map_err(|err| {
  315    315   
            ::aws_smithy_types::error::operation::BuildError::invalid_field(
  316    316   
                "performance_config_latency",
  317    317   
                format!("`{}` cannot be used as a header value: {}", &header_value, err),
  318    318   
            )
  319    319   
        })?;
  320    320   
        builder = builder.header("X-Amzn-Bedrock-PerformanceConfig-Latency", header_value);
  321    321   
    }
  322    322   
    Ok(builder)
  323    323   
}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/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/cloudwatchlogs/Cargo.toml

@@ -1,1 +158,159 @@
   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     24   
features = ["event-stream"]
   25         -
version = "1.5.18"
          25  +
version = "1.6.0"
   26     26   
   27     27   
[dependencies.aws-smithy-async]
   28     28   
path = "../aws-smithy-async"
   29         -
version = "1.2.7"
          29  +
version = "1.2.8"
   30     30   
   31     31   
[dependencies.aws-smithy-eventstream]
   32     32   
path = "../aws-smithy-eventstream"
   33         -
version = "0.60.14"
          33  +
version = "0.60.15"
   34     34   
   35     35   
[dependencies.aws-smithy-http]
   36     36   
path = "../aws-smithy-http"
   37     37   
features = ["event-stream"]
   38         -
version = "0.62.6"
          38  +
version = "0.63.0"
   39     39   
   40     40   
[dependencies.aws-smithy-json]
   41     41   
path = "../aws-smithy-json"
   42         -
version = "0.61.9"
          42  +
version = "0.62.0"
   43     43   
   44     44   
[dependencies.aws-smithy-observability]
   45     45   
path = "../aws-smithy-observability"
   46         -
version = "0.2.0"
          46  +
version = "0.2.1"
   47     47   
   48     48   
[dependencies.aws-smithy-runtime]
   49     49   
path = "../aws-smithy-runtime"
   50     50   
features = ["client"]
   51         -
version = "1.9.8"
          51  +
version = "1.10.0"
   52     52   
   53     53   
[dependencies.aws-smithy-runtime-api]
   54     54   
path = "../aws-smithy-runtime-api"
   55         -
features = ["client", "http-02x"]
   56         -
version = "1.10.0"
          55  +
features = ["client", "http-1x"]
          56  +
version = "1.11.0"
   57     57   
   58     58   
[dependencies.aws-smithy-types]
   59     59   
path = "../aws-smithy-types"
   60         -
version = "1.3.6"
          60  +
features = ["http-body-1-x"]
          61  +
version = "1.4.0"
   61     62   
   62     63   
[dependencies.aws-types]
   63     64   
path = "../aws-types"
   64     65   
version = "1.3.11"
   65     66   
   66     67   
[dependencies.bytes]
   67     68   
version = "1.4.0"
   68     69   
   69     70   
[dependencies.fastrand]
   70     71   
version = "2.0.0"
   71     72   
   72     73   
[dependencies.http]
   73     74   
version = "0.2.9"
   74     75   
          76  +
[dependencies.http-1x]
          77  +
version = "1"
          78  +
package = "http"
          79  +
   75     80   
[dependencies.regex-lite]
   76     81   
version = "0.1.5"
   77     82   
   78     83   
[dependencies.tracing]
   79     84   
version = "0.1"
   80     85   
[dev-dependencies.aws-config]
   81     86   
path = "../aws-config"
   82     87   
version = "1.8.12"
   83     88   
   84     89   
[dev-dependencies.aws-credential-types]
   85     90   
path = "../aws-credential-types"
   86     91   
features = ["test-util"]
   87     92   
version = "1.2.11"
   88     93   
   89     94   
[dev-dependencies.aws-runtime]
   90     95   
path = "../aws-runtime"
   91     96   
features = ["test-util"]
   92         -
version = "1.5.18"
          97  +
version = "1.6.0"
   93     98   
   94     99   
[dev-dependencies.aws-smithy-async]
   95    100   
path = "../aws-smithy-async"
   96    101   
features = ["test-util"]
   97         -
version = "1.2.7"
         102  +
version = "1.2.8"
   98    103   
   99    104   
[dev-dependencies.aws-smithy-eventstream]
  100    105   
path = "../aws-smithy-eventstream"
  101    106   
features = ["test-util"]
  102         -
version = "0.60.14"
         107  +
version = "0.60.15"
  103    108   
  104    109   
[dev-dependencies.aws-smithy-http-client]
  105    110   
path = "../aws-smithy-http-client"
  106    111   
features = ["test-util", "wire-mock"]
  107         -
version = "1.1.5"
         112  +
version = "1.1.6"
  108    113   
  109    114   
[dev-dependencies.aws-smithy-protocol-test]
  110    115   
path = "../aws-smithy-protocol-test"
  111         -
version = "0.63.7"
         116  +
version = "0.63.8"
  112    117   
  113    118   
[dev-dependencies.aws-smithy-runtime]
  114    119   
path = "../aws-smithy-runtime"
  115    120   
features = ["test-util"]
  116         -
version = "1.9.8"
         121  +
version = "1.10.0"
  117    122   
  118    123   
[dev-dependencies.aws-smithy-runtime-api]
  119    124   
path = "../aws-smithy-runtime-api"
  120    125   
features = ["test-util"]
  121         -
version = "1.10.0"
         126  +
version = "1.11.0"
  122    127   
  123    128   
[dev-dependencies.aws-smithy-types]
  124    129   
path = "../aws-smithy-types"
  125         -
features = ["test-util"]
  126         -
version = "1.3.6"
         130  +
features = ["http-body-1-x", "test-util"]
         131  +
version = "1.4.0"
  127    132   
  128    133   
[dev-dependencies.futures-util]
  129    134   
version = "0.3.25"
  130    135   
features = ["alloc"]
  131    136   
default-features = false
  132    137   
  133         -
[dev-dependencies.http-1x]
  134         -
version = "1"
  135         -
package = "http"
  136         -
  137    138   
[dev-dependencies.proptest]
  138    139   
version = "1"
  139    140   
  140    141   
[dev-dependencies.serde_json]
  141    142   
version = "1.0.0"
  142    143   
  143    144   
[dev-dependencies.tokio]
  144    145   
version = "1.23.1"
  145    146   
features = ["macros", "test-util", "rt-multi-thread"]
  146    147

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/json_errors.rs

@@ -1,1 +45,45 @@
    5      5   
 */
    6      6   
    7      7   
use aws_smithy_json::deserialize::token::skip_value;
    8      8   
use aws_smithy_json::deserialize::{error::DeserializeError, json_token_iter, Token};
    9      9   
use aws_smithy_runtime_api::http::Headers;
   10     10   
use aws_smithy_types::error::metadata::{Builder as ErrorMetadataBuilder, ErrorMetadata};
   11     11   
use std::borrow::Cow;
   12     12   
   13     13   
// currently only used by AwsJson
   14     14   
#[allow(unused)]
   15         -
pub fn is_error<B>(response: &http::Response<B>) -> bool {
          15  +
pub fn is_error<B>(response: &http_1x::Response<B>) -> bool {
   16     16   
    !response.status().is_success()
   17     17   
}
   18     18   
   19     19   
fn sanitize_error_code(error_code: &str) -> &str {
   20     20   
    // Trim a trailing URL from the error code, which is done by removing the longest suffix
   21     21   
    // beginning with a `:`
   22     22   
    let error_code = match error_code.find(':') {
   23     23   
        Some(idx) => &error_code[..idx],
   24     24   
        None => error_code,
   25     25   
    };
@@ -60,60 +120,120 @@
   80     80   
#[cfg(test)]
   81     81   
mod test {
   82     82   
    use crate::json_errors::{parse_error_body, parse_error_metadata, sanitize_error_code};
   83     83   
    use aws_smithy_runtime_api::client::orchestrator::HttpResponse;
   84     84   
    use aws_smithy_types::{body::SdkBody, error::ErrorMetadata};
   85     85   
    use std::borrow::Cow;
   86     86   
   87     87   
    #[test]
   88     88   
    fn error_metadata() {
   89     89   
        let response = HttpResponse::try_from(
   90         -
            http::Response::builder()
          90  +
            http_1x::Response::builder()
   91     91   
                .body(SdkBody::from(r#"{ "__type": "FooError", "message": "Go to foo" }"#))
   92     92   
                .unwrap(),
   93     93   
        )
   94     94   
        .unwrap();
   95     95   
        assert_eq!(
   96     96   
            parse_error_metadata(response.body().bytes().unwrap(), response.headers())
   97     97   
                .unwrap()
   98     98   
                .build(),
   99     99   
            ErrorMetadata::builder().code("FooError").message("Go to foo").build()
  100    100   
        )
@@ -129,129 +180,180 @@
  149    149   
  150    150   
    #[test]
  151    151   
    fn sanitize_namespace() {
  152    152   
        assert_eq!(sanitize_error_code("aws.protocoltests.restjson#FooError"), "FooError");
  153    153   
    }
  154    154   
  155    155   
    // services like lambda use an alternate `Message` instead of `message`
  156    156   
    #[test]
  157    157   
    fn alternative_error_message_names() {
  158    158   
        let response = HttpResponse::try_from(
  159         -
            http::Response::builder()
         159  +
            http_1x::Response::builder()
  160    160   
                .header("x-amzn-errortype", "ResourceNotFoundException")
  161    161   
                .body(SdkBody::from(
  162    162   
                    r#"{
  163    163   
                    "Type": "User",
  164    164   
                    "Message": "Functions from 'us-west-2' are not reachable from us-east-1"
  165    165   
                }"#,
  166    166   
                ))
  167    167   
                .unwrap(),
  168    168   
        )
  169    169   
        .unwrap();

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/associate_kms_key.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::associate_kms_key::AssociateKmsKeyInput,
  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, "/").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::associate_kms_key::AssociateKmsKeyInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.AssociateKmsKey",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_associate_kms_key::ser_associate_kms_key_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct AssociateKmsKeyEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for AssociateKmsKeyEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "AssociateKmsKeyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/cancel_export_task.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::cancel_export_task::CancelExportTaskInput,
  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, "/").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::cancel_export_task::CancelExportTaskInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.CancelExportTask",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_cancel_export_task::ser_cancel_export_task_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct CancelExportTaskEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CancelExportTaskEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "CancelExportTaskEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_delivery.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::create_delivery::CreateDeliveryInput,
  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, "/").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_delivery::CreateDeliveryInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.CreateDelivery",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_delivery::ser_create_delivery_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct CreateDeliveryEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateDeliveryEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "CreateDeliveryEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_export_task.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::create_export_task::CreateExportTaskInput,
  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, "/").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_export_task::CreateExportTaskInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.CreateExportTask",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_export_task::ser_create_export_task_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct CreateExportTaskEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateExportTaskEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "CreateExportTaskEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_anomaly_detector.rs

@@ -171,171 +251,251 @@
  191    191   
                _input: &crate::operation::create_log_anomaly_detector::CreateLogAnomalyDetectorInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/").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::create_log_anomaly_detector::CreateLogAnomalyDetectorInput,
  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("POST").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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  209    209   
            builder = _header_serialization_settings.set_default_header(
  210    210   
                builder,
  211         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         211  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212    212   
                "Logs_20140328.CreateLogAnomalyDetector",
  213    213   
            );
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(
  217    217   
            crate::protocol_serde::shape_create_log_anomaly_detector::ser_create_log_anomaly_detector_input(&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 CreateLogAnomalyDetectorEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateLogAnomalyDetectorEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "CreateLogAnomalyDetectorEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_group.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::create_log_group::CreateLogGroupInput,
  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, "/").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_log_group::CreateLogGroupInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.CreateLogGroup",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_log_group::ser_create_log_group_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct CreateLogGroupEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateLogGroupEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "CreateLogGroupEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/create_log_stream.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::create_log_stream::CreateLogStreamInput,
  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, "/").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_log_stream::CreateLogStreamInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.CreateLogStream",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_create_log_stream::ser_create_log_stream_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct CreateLogStreamEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CreateLogStreamEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "CreateLogStreamEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_account_policy.rs

@@ -171,171 +251,251 @@
  191    191   
                _input: &crate::operation::delete_account_policy::DeleteAccountPolicyInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/").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::delete_account_policy::DeleteAccountPolicyInput,
  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("POST").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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  209    209   
            builder = _header_serialization_settings.set_default_header(
  210    210   
                builder,
  211         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         211  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212    212   
                "Logs_20140328.DeleteAccountPolicy",
  213    213   
            );
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_account_policy::ser_delete_account_policy_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 DeleteAccountPolicyEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteAccountPolicyEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "DeleteAccountPolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_data_protection_policy.rs

@@ -171,171 +251,251 @@
  191    191   
                _input: &crate::operation::delete_data_protection_policy::DeleteDataProtectionPolicyInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/").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::delete_data_protection_policy::DeleteDataProtectionPolicyInput,
  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("POST").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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  209    209   
            builder = _header_serialization_settings.set_default_header(
  210    210   
                builder,
  211         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         211  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212    212   
                "Logs_20140328.DeleteDataProtectionPolicy",
  213    213   
            );
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(
  217    217   
            crate::protocol_serde::shape_delete_data_protection_policy::ser_delete_data_protection_policy_input(&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 DeleteDataProtectionPolicyEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteDataProtectionPolicyEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "DeleteDataProtectionPolicyEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_delivery.rs

@@ -165,165 +243,243 @@
  185    185   
                _input: &crate::operation::delete_delivery::DeleteDeliveryInput,
  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, "/").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::delete_delivery::DeleteDeliveryInput,
  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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  203    203   
            builder = _header_serialization_settings.set_default_header(
  204    204   
                builder,
  205         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         205  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  206    206   
                "Logs_20140328.DeleteDelivery",
  207    207   
            );
  208    208   
            builder
  209    209   
        };
  210    210   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_delete_delivery::ser_delete_delivery_input(&input)?);
  211    211   
        if let Some(content_length) = body.content_length() {
  212    212   
            let content_length = content_length.to_string();
  213         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         213  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  214    214   
        }
  215    215   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  216    216   
    }
  217    217   
}
  218    218   
#[derive(Debug)]
  219    219   
struct DeleteDeliveryEndpointParamsInterceptor;
  220    220   
  221    221   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteDeliveryEndpointParamsInterceptor {
  222    222   
    fn name(&self) -> &'static str {
  223    223   
        "DeleteDeliveryEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/cloudwatchlogs/src/operation/delete_delivery_destination.rs

@@ -171,171 +251,251 @@
  191    191   
                _input: &crate::operation::delete_delivery_destination::DeleteDeliveryDestinationInput,
  192    192   
                output: &mut ::std::string::String,
  193    193   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  194    194   
                use ::std::fmt::Write as _;
  195    195   
                ::std::write!(output, "/").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::delete_delivery_destination::DeleteDeliveryDestinationInput,
  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("POST").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/x-amz-json-1.1");
         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/x-amz-json-1.1");
  209    209   
            builder = _header_serialization_settings.set_default_header(
  210    210   
                builder,
  211         -
                ::http::header::HeaderName::from_static("x-amz-target"),
         211  +
                ::http_1x::header::HeaderName::from_static("x-amz-target"),
  212    212   
                "Logs_20140328.DeleteDeliveryDestination",
  213    213   
            );
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(
  217    217   
            crate::protocol_serde::shape_delete_delivery_destination::ser_delete_delivery_destination_input(&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 DeleteDeliveryDestinationEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteDeliveryDestinationEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "DeleteDeliveryDestinationEndpointParamsInterceptor"