AWS SDK

AWS SDK

rev. d06a46cae0f385cdae37a9f8264db3469a090ab5 (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-types/src/byte_stream/bytestream_util.rs

@@ -180,180 +256,268 @@
  200    200   
                length
  201    201   
            }
  202    202   
            Some(Length::UpTo(length)) => min(length, remaining_file_length),
  203    203   
            None => remaining_file_length,
  204    204   
        };
  205    205   
  206    206   
        if let Some(path) = self.path {
  207    207   
            let body_loader = move || {
  208    208   
                // If an offset was provided, seeking will be handled in `PathBody::poll_data` each
  209    209   
                // time the file is loaded.
  210         -
                SdkBody::from_body_0_4_internal(PathBody::from_path(
         210  +
                #[cfg(not(feature = "http-body-1-x"))]
         211  +
                return SdkBody::from_body_0_4_internal(PathBody::from_path(
  211    212   
                    path.clone(),
  212    213   
                    length,
  213    214   
                    buffer_size,
  214    215   
                    self.offset,
  215         -
                ))
         216  +
                ));
         217  +
                #[cfg(feature = "http-body-1-x")]
         218  +
                return SdkBody::from_body_1_x_internal(PathBody::from_path(
         219  +
                    path.clone(),
         220  +
                    length,
         221  +
                    buffer_size,
         222  +
                    self.offset,
         223  +
                ));
  216    224   
            };
  217    225   
  218    226   
            Ok(ByteStream::new(SdkBody::retryable(body_loader)))
  219    227   
        } else if let Some(mut file) = self.file {
  220    228   
            // When starting from a `File`, we need to do our own seeking
  221    229   
            if offset != 0 {
  222    230   
                let _s = file.seek(io::SeekFrom::Start(offset)).await?;
  223    231   
            }
  224    232   
         233  +
            #[cfg(not(feature = "http-body-1-x"))]
  225    234   
            let body =
  226    235   
                SdkBody::from_body_0_4_internal(PathBody::from_file(file, length, buffer_size));
         236  +
            #[cfg(feature = "http-body-1-x")]
         237  +
            let body =
         238  +
                SdkBody::from_body_1_x_internal(PathBody::from_file(file, length, buffer_size));
  227    239   
  228    240   
            Ok(ByteStream::new(body))
  229    241   
        } else {
  230    242   
            panic!("FsBuilder constructed without a file or a path")
  231    243   
        }
  232    244   
    }
  233    245   
  234    246   
    async fn get_file_size(&self) -> Result<u64, Error> {
  235    247   
        Ok(match self.path.as_ref() {
  236    248   
            Some(path) => tokio::fs::metadata(path).await,

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-wasm/Cargo.toml

@@ -1,1 +0,34 @@
    9      9   
repository = "https://github.com/awslabs/smithy-rs"
   10     10   
rust-version = "1.88"
   11     11   
[package.metadata.docs.rs]
   12     12   
all-features = true
   13     13   
targets = ["x86_64-unknown-linux-gnu"]
   14     14   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   15     15   
rustdoc-args = ["--cfg", "docsrs"]
   16     16   
   17     17   
[dependencies]
   18     18   
bytes = "1.10.0"
   19         -
http = "1.0.0"
          19  +
http = "1.3.1"
   20     20   
tracing = "0.1.40"
   21     21   
wasip2 = "1.0.1"
   22     22   
   23     23   
[dependencies.aws-smithy-runtime-api]
   24     24   
path = "../aws-smithy-runtime-api"
   25     25   
features = ["http-1x"]
   26         -
version = "1.10.0"
          26  +
version = "1.11.0"
   27     27   
   28     28   
[dependencies.aws-smithy-http]
   29     29   
path = "../aws-smithy-http"
   30         -
version = "0.62.6"
          30  +
version = "0.63.0"
   31     31   
   32     32   
[dependencies.aws-smithy-types]
   33     33   
path = "../aws-smithy-types"
   34         -
version = "1.3.6"
          34  +
version = "1.4.0"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-xml/Cargo.toml

@@ -1,1 +0,26 @@
   16     16   
   17     17   
[dependencies]
   18     18   
xmlparser = "0.13.5"
   19     19   
   20     20   
[dev-dependencies]
   21     21   
base64 = "0.13.0"
   22     22   
proptest = "1"
   23     23   
   24     24   
[dev-dependencies.aws-smithy-protocol-test]
   25     25   
path = "../aws-smithy-protocol-test"
   26         -
version = "0.63.7"
          26  +
version = "0.63.8"

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

@@ -4,4 +71,71 @@
   24     24   
   25     25   
[dependencies]
   26     26   
tracing = "0.1.40"
   27     27   
   28     28   
[dependencies.aws-credential-types]
   29     29   
path = "../aws-credential-types"
   30     30   
version = "1.2.11"
   31     31   
   32     32   
[dependencies.aws-smithy-async]
   33     33   
path = "../aws-smithy-async"
   34         -
version = "1.2.7"
          34  +
version = "1.2.8"
   35     35   
   36     36   
[dependencies.aws-smithy-types]
   37     37   
path = "../aws-smithy-types"
   38         -
version = "1.3.6"
          38  +
version = "1.4.0"
   39     39   
   40     40   
[dependencies.aws-smithy-runtime]
   41     41   
path = "../aws-smithy-runtime"
   42     42   
optional = true
   43         -
version = "1.9.8"
          43  +
version = "1.10.0"
   44     44   
   45     45   
[dependencies.aws-smithy-runtime-api]
   46     46   
path = "../aws-smithy-runtime-api"
   47     47   
features = ["client"]
   48         -
version = "1.10.0"
          48  +
version = "1.11.0"
   49     49   
   50     50   
[dependencies.hyper-rustls]
   51     51   
version = "0.24.2"
   52     52   
optional = true
   53     53   
default-features = false
   54     54   
features = ["http2", "webpki-roots"]
   55     55   
   56     56   
[dev-dependencies]
   57     57   
http = "0.2.4"
   58     58   
tempfile = "3.16.0"
   59     59   
tracing-test = "0.2.5"
   60     60   
   61     61   
[dev-dependencies.tokio]
   62     62   
version = "1"
   63     63   
features = ["rt", "macros"]
   64     64   
   65     65   
[dev-dependencies.aws-smithy-runtime-api]
   66     66   
path = "../aws-smithy-runtime-api"
   67     67   
features = ["http-02x"]
   68         -
version = "1.10.0"
          68  +
version = "1.11.0"
   69     69   
   70     70   
[build-dependencies]
   71     71   
rustc_version = "0.4.0"

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

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

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/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/bedrockruntime/src/operation/apply_guardrail.rs

@@ -194,194 +267,267 @@
  214    214   
                    "/guardrail/{guardrailIdentifier}/version/{guardrailVersion}/apply",
  215    215   
                    guardrailIdentifier = guardrail_identifier,
  216    216   
                    guardrailVersion = guardrail_version
  217    217   
                )
  218    218   
                .expect("formatting should succeed");
  219    219   
                ::std::result::Result::Ok(())
  220    220   
            }
  221    221   
            #[allow(clippy::unnecessary_wraps)]
  222    222   
            fn update_http_builder(
  223    223   
                input: &crate::operation::apply_guardrail::ApplyGuardrailInput,
  224         -
                builder: ::http::request::Builder,
  225         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         224  +
                builder: ::http_1x::request::Builder,
         225  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  226    226   
                let mut uri = ::std::string::String::new();
  227    227   
                uri_base(input, &mut uri)?;
  228    228   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  229    229   
            }
  230         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  231         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         230  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         231  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  232    232   
            builder
  233    233   
        };
  234    234   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_apply_guardrail::ser_apply_guardrail_input(&input)?);
  235    235   
        if let Some(content_length) = body.content_length() {
  236    236   
            let content_length = content_length.to_string();
  237         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         237  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  238    238   
        }
  239    239   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  240    240   
    }
  241    241   
}
  242    242   
#[derive(Debug)]
  243    243   
struct ApplyGuardrailEndpointParamsInterceptor;
  244    244   
  245    245   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ApplyGuardrailEndpointParamsInterceptor {
  246    246   
    fn name(&self) -> &'static str {
  247    247   
        "ApplyGuardrailEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/converse.rs

@@ -171,171 +244,244 @@
  191    191   
                        "model_id",
  192    192   
                        "cannot be empty or unset",
  193    193   
                    ));
  194    194   
                }
  195    195   
                ::std::write!(output, "/model/{modelId}/converse", modelId = model_id).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::converse::ConverseInput,
  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/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_converse::ser_converse_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 ConverseEndpointParamsInterceptor;
  221    221   
  222    222   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConverseEndpointParamsInterceptor {
  223    223   
    fn name(&self) -> &'static str {
  224    224   
        "ConverseEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/converse_stream.rs

@@ -188,188 +261,261 @@
  208    208   
                        "model_id",
  209    209   
                        "cannot be empty or unset",
  210    210   
                    ));
  211    211   
                }
  212    212   
                ::std::write!(output, "/model/{modelId}/converse-stream", modelId = model_id).expect("formatting should succeed");
  213    213   
                ::std::result::Result::Ok(())
  214    214   
            }
  215    215   
            #[allow(clippy::unnecessary_wraps)]
  216    216   
            fn update_http_builder(
  217    217   
                input: &crate::operation::converse_stream::ConverseStreamInput,
  218         -
                builder: ::http::request::Builder,
  219         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         218  +
                builder: ::http_1x::request::Builder,
         219  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  220    220   
                let mut uri = ::std::string::String::new();
  221    221   
                uri_base(input, &mut uri)?;
  222    222   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  223    223   
            }
  224         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  225         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         224  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         225  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  226    226   
            builder
  227    227   
        };
  228    228   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_converse_stream::ser_converse_stream_input(&input)?);
  229    229   
        if let Some(content_length) = body.content_length() {
  230    230   
            let content_length = content_length.to_string();
  231         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         231  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  232    232   
        }
  233    233   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  234    234   
    }
  235    235   
}
  236    236   
#[derive(Debug)]
  237    237   
struct ConverseStreamEndpointParamsInterceptor;
  238    238   
  239    239   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for ConverseStreamEndpointParamsInterceptor {
  240    240   
    fn name(&self) -> &'static str {
  241    241   
        "ConverseStreamEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/count_tokens.rs

@@ -176,176 +249,249 @@
  196    196   
                        "model_id",
  197    197   
                        "cannot be empty or unset",
  198    198   
                    ));
  199    199   
                }
  200    200   
                ::std::write!(output, "/model/{modelId}/count-tokens", modelId = model_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::count_tokens::CountTokensInput,
  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/json");
         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/json");
  214    214   
            builder
  215    215   
        };
  216    216   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_count_tokens::ser_count_tokens_input(&input)?);
  217    217   
        if let Some(content_length) = body.content_length() {
  218    218   
            let content_length = content_length.to_string();
  219         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         219  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  220    220   
        }
  221    221   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  222    222   
    }
  223    223   
}
  224    224   
#[derive(Debug)]
  225    225   
struct CountTokensEndpointParamsInterceptor;
  226    226   
  227    227   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CountTokensEndpointParamsInterceptor {
  228    228   
    fn name(&self) -> &'static str {
  229    229   
        "CountTokensEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/get_async_invoke.rs

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

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model.rs

@@ -177,177 +251,251 @@
  197    197   
                        "model_id",
  198    198   
                        "cannot be empty or unset",
  199    199   
                    ));
  200    200   
                }
  201    201   
                ::std::write!(output, "/model/{modelId}/invoke", modelId = model_id).expect("formatting should succeed");
  202    202   
                ::std::result::Result::Ok(())
  203    203   
            }
  204    204   
            #[allow(clippy::unnecessary_wraps)]
  205    205   
            fn update_http_builder(
  206    206   
                input: &crate::operation::invoke_model::InvokeModelInput,
  207         -
                builder: ::http::request::Builder,
  208         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         207  +
                builder: ::http_1x::request::Builder,
         208  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  209    209   
                let mut uri = ::std::string::String::new();
  210    210   
                uri_base(input, &mut uri)?;
  211    211   
                let builder = crate::protocol_serde::shape_invoke_model::ser_invoke_model_headers(input, builder)?;
  212    212   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  213    213   
            }
  214         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  215         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         214  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         215  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  216    216   
            builder
  217    217   
        };
  218    218   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_invoke_model_input::ser_body_http_payload(input.body)?);
  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 InvokeModelEndpointParamsInterceptor;
  228    228   
  229    229   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeModelEndpointParamsInterceptor {
  230    230   
    fn name(&self) -> &'static str {
  231    231   
        "InvokeModelEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model_with_bidirectional_stream.rs

@@ -196,196 +279,280 @@
  216    216   
                        "model_id",
  217    217   
                        "cannot be empty or unset",
  218    218   
                    ));
  219    219   
                }
  220    220   
                ::std::write!(output, "/model/{modelId}/invoke-with-bidirectional-stream", modelId = model_id).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::invoke_model_with_bidirectional_stream::InvokeModelWithBidirectionalStreamInput,
  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())?;
  233         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
         232  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         233  +
            builder =
         234  +
                _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
  234    235   
            builder
  235    236   
        };
  236    237   
        let body = ::aws_smithy_types::body::SdkBody::from({
  237    238   
            let error_marshaller = crate::event_stream_serde::InvokeModelWithBidirectionalStreamInputErrorMarshaller::new();
  238    239   
            let marshaller = crate::event_stream_serde::InvokeModelWithBidirectionalStreamInputMarshaller::new();
  239    240   
            let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
  240    241   
            _cfg.interceptor_state().store_put(signer_sender);
  241    242   
            ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.body.into_body_stream(
  242    243   
                marshaller,
  243    244   
                error_marshaller,
  244    245   
                signer,
  245    246   
            )))
  246    247   
        });
  247    248   
        if let Some(content_length) = body.content_length() {
  248    249   
            let content_length = content_length.to_string();
  249         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         250  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  250    251   
        }
  251    252   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  252    253   
    }
  253    254   
}
  254    255   
#[derive(Debug)]
  255    256   
struct InvokeModelWithBidirectionalStreamEndpointParamsInterceptor;
  256    257   
  257    258   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeModelWithBidirectionalStreamEndpointParamsInterceptor {
  258    259   
    fn name(&self) -> &'static str {
  259    260   
        "InvokeModelWithBidirectionalStreamEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/invoke_model_with_response_stream.rs

@@ -196,196 +273,273 @@
  216    216   
                        "model_id",
  217    217   
                        "cannot be empty or unset",
  218    218   
                    ));
  219    219   
                }
  220    220   
                ::std::write!(output, "/model/{modelId}/invoke-with-response-stream", modelId = model_id).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::invoke_model_with_response_stream::InvokeModelWithResponseStreamInput,
  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   
                let builder =
  231    231   
                    crate::protocol_serde::shape_invoke_model_with_response_stream::ser_invoke_model_with_response_stream_headers(input, builder)?;
  232    232   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  233    233   
            }
  234         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  235         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/octet-stream");
         234  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         235  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/octet-stream");
  236    236   
            builder
  237    237   
        };
  238    238   
        let body = ::aws_smithy_types::body::SdkBody::from(
  239    239   
            crate::protocol_serde::shape_invoke_model_with_response_stream_input::ser_body_http_payload(input.body)?,
  240    240   
        );
  241    241   
        if let Some(content_length) = body.content_length() {
  242    242   
            let content_length = content_length.to_string();
  243         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         243  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  244    244   
        }
  245    245   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  246    246   
    }
  247    247   
}
  248    248   
#[derive(Debug)]
  249    249   
struct InvokeModelWithResponseStreamEndpointParamsInterceptor;
  250    250   
  251    251   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for InvokeModelWithResponseStreamEndpointParamsInterceptor {
  252    252   
    fn name(&self) -> &'static str {
  253    253   
        "InvokeModelWithResponseStreamEndpointParamsInterceptor"

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/list_async_invokes.rs

@@ -214,214 +281,281 @@
  234    234   
                if let ::std::option::Option::Some(inner_7) = &_input.sort_order {
  235    235   
                    {
  236    236   
                        query.push_kv("sortOrder", &::aws_smithy_http::query::fmt_string(inner_7));
  237    237   
                    }
  238    238   
                }
  239    239   
                ::std::result::Result::Ok(())
  240    240   
            }
  241    241   
            #[allow(clippy::unnecessary_wraps)]
  242    242   
            fn update_http_builder(
  243    243   
                input: &crate::operation::list_async_invokes::ListAsyncInvokesInput,
  244         -
                builder: ::http::request::Builder,
  245         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         244  +
                builder: ::http_1x::request::Builder,
         245  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  246    246   
                let mut uri = ::std::string::String::new();
  247    247   
                uri_base(input, &mut uri)?;
  248    248   
                uri_query(input, &mut uri)?;
  249    249   
                ::std::result::Result::Ok(builder.method("GET").uri(uri))
  250    250   
            }
  251         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
         251  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
  252    252   
            builder
  253    253   
        };
  254    254   
        let body = ::aws_smithy_types::body::SdkBody::from("");
  255    255   
  256    256   
        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
  257    257   
    }
  258    258   
}
  259    259   
#[derive(Debug)]
  260    260   
struct ListAsyncInvokesEndpointParamsInterceptor;
  261    261

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/operation/start_async_invoke.rs

@@ -172,172 +245,245 @@
  192    192   
                _input: &crate::operation::start_async_invoke::StartAsyncInvokeInput,
  193    193   
                output: &mut ::std::string::String,
  194    194   
            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
  195    195   
                use ::std::fmt::Write as _;
  196    196   
                ::std::write!(output, "/async-invoke").expect("formatting should succeed");
  197    197   
                ::std::result::Result::Ok(())
  198    198   
            }
  199    199   
            #[allow(clippy::unnecessary_wraps)]
  200    200   
            fn update_http_builder(
  201    201   
                input: &crate::operation::start_async_invoke::StartAsyncInvokeInput,
  202         -
                builder: ::http::request::Builder,
  203         -
            ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
         202  +
                builder: ::http_1x::request::Builder,
         203  +
            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
  204    204   
                let mut uri = ::std::string::String::new();
  205    205   
                uri_base(input, &mut uri)?;
  206    206   
                ::std::result::Result::Ok(builder.method("POST").uri(uri))
  207    207   
            }
  208         -
            let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
  209         -
            builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/json");
         208  +
            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
         209  +
            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
  210    210   
            builder
  211    211   
        };
  212    212   
        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_start_async_invoke::ser_start_async_invoke_input(&input)?);
  213    213   
        if let Some(content_length) = body.content_length() {
  214    214   
            let content_length = content_length.to_string();
  215         -
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
         215  +
            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
  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 StartAsyncInvokeEndpointParamsInterceptor;
  222    222   
  223    223   
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StartAsyncInvokeEndpointParamsInterceptor {
  224    224   
    fn name(&self) -> &'static str {
  225    225   
        "StartAsyncInvokeEndpointParamsInterceptor"