AWS SDK

AWS SDK

rev. 595a9dbeb2bcaa5eb380ce8a3ff81a559073e046 (ignoring whitespace)

Files changed:

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

@@ -23,23 +123,123 @@
   43     43   
[dependencies.aws-smithy-http]
   44     44   
path = "../aws-smithy-http"
   45     45   
version = "0.62.1"
   46     46   
   47     47   
[dependencies.aws-smithy-observability]
   48     48   
path = "../aws-smithy-observability"
   49     49   
version = "0.1.3"
   50     50   
   51     51   
[dependencies.aws-smithy-runtime-api]
   52     52   
path = "../aws-smithy-runtime-api"
   53         -
version = "1.8.0"
          53  +
version = "1.8.1"
   54     54   
   55     55   
[dependencies.aws-smithy-types]
   56     56   
path = "../aws-smithy-types"
   57     57   
features = ["http-body-0-4-x"]
   58         -
version = "1.3.1"
          58  +
version = "1.3.2"
   59     59   
   60     60   
[dependencies.aws-smithy-http-client]
   61     61   
path = "../aws-smithy-http-client"
   62     62   
optional = true
   63         -
version = "1.0.3"
          63  +
version = "1.0.5"
   64     64   
   65     65   
[dependencies.http-02x]
   66     66   
package = "http"
   67     67   
version = "0.2.9"
   68     68   
   69     69   
[dependencies.http-1x]
   70     70   
package = "http"
   71     71   
version = "1"
   72     72   
   73     73   
[dependencies.http-body-04x]
   74     74   
package = "http-body"
   75     75   
version = "0.4.5"
   76     76   
   77     77   
[dependencies.http-body-1x]
   78     78   
package = "http-body"
   79     79   
version = "1"
   80     80   
   81     81   
[dependencies.tokio]
   82     82   
version = "1.40.0"
   83     83   
features = []
   84     84   
   85     85   
[dependencies.tracing-subscriber]
   86     86   
version = "0.3.16"
   87     87   
optional = true
   88     88   
features = ["env-filter", "fmt", "json"]
   89     89   
   90     90   
[dev-dependencies]
   91     91   
approx = "0.5.1"
   92     92   
fastrand = "2.3.0"
   93     93   
futures-util = "0.3.29"
   94     94   
pretty_assertions = "1.4.0"
   95     95   
tracing-test = "0.2.1"
   96     96   
   97     97   
[dev-dependencies.aws-smithy-async]
   98     98   
path = "../aws-smithy-async"
   99     99   
features = ["rt-tokio", "test-util"]
  100    100   
version = "1.2.5"
  101    101   
  102    102   
[dev-dependencies.aws-smithy-runtime-api]
  103    103   
path = "../aws-smithy-runtime-api"
  104    104   
features = ["test-util"]
  105         -
version = "1.8.0"
         105  +
version = "1.8.1"
  106    106   
  107    107   
[dev-dependencies.aws-smithy-types]
  108    108   
path = "../aws-smithy-types"
  109    109   
features = ["test-util"]
  110         -
version = "1.3.1"
         110  +
version = "1.3.2"
  111    111   
  112    112   
[dev-dependencies.tokio]
  113    113   
version = "1.25"
  114    114   
features = ["macros", "rt", "rt-multi-thread", "test-util", "full"]
  115    115   
  116    116   
[dev-dependencies.tracing-subscriber]
  117    117   
version = "0.3.16"
  118    118   
features = ["env-filter"]
  119    119   
  120    120   
[dev-dependencies.hyper_0_14]

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

@@ -1,1 +42,42 @@
   13     13   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   14     14   
rustdoc-args = ["--cfg", "docsrs"]
   15     15   
   16     16   
[features]
   17     17   
convert-chrono = ["aws-smithy-types", "chrono"]
   18     18   
convert-time = ["aws-smithy-types", "time"]
   19     19   
convert-streams = ["aws-smithy-async", "futures-core"]
   20     20   
[dependencies.aws-smithy-types]
   21     21   
path = "../aws-smithy-types"
   22     22   
optional = true
   23         -
version = "1.3.1"
          23  +
version = "1.3.2"
   24     24   
   25     25   
[dependencies.aws-smithy-async]
   26     26   
path = "../aws-smithy-async"
   27     27   
optional = true
   28     28   
version = "1.2.5"
   29     29   
   30     30   
[dependencies.chrono]
   31     31   
version = "0.4.35"
   32     32   
optional = true
   33     33   
default-features = false

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

@@ -1,1 +33,33 @@
    1      1   
[package]
    2      2   
name = "aws-smithy-types"
    3         -
version = "1.3.1"
           3  +
version = "1.3.2"
    4      4   
authors = [
    5      5   
    "AWS Rust SDK Team <aws-sdk-rust@amazon.com>",
    6      6   
    "Russell Cohen <rcoh@amazon.com>",
    7      7   
]
    8      8   
description = "Types for smithy-rs codegen."
    9      9   
edition = "2021"
   10     10   
license = "Apache-2.0"
   11     11   
repository = "https://github.com/smithy-lang/smithy-rs"
   12     12   
   13     13   
[features]

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

@@ -17,17 +50,50 @@
   37     37   
edition = "2021"
   38     38   
   39     39   
[package.metadata]
   40     40   
cargo-fuzz = true
   41     41   
   42     42   
[dependencies]
   43     43   
libfuzzer-sys = "=0.4.7"
   44     44   
   45     45   
[dependencies.aws-smithy-types]
   46     46   
path = ".."
   47         -
version = "1.3.1"
          47  +
version = "1.3.2"
   48     48   
   49     49   
[workspace]
   50     50   
members = ["."]

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

@@ -713,713 +773,773 @@
  733    733   
        }
  734    734   
    }
  735    735   
}
  736    736   
  737    737   
/// Iterator of items returned from [`ConfigBag`].
  738    738   
pub struct ItemIter<'a, T> {
  739    739   
    inner: BagIter<'a>,
  740    740   
    t: PhantomData<T>,
  741    741   
}
  742    742   
  743         -
impl<'a, T> Debug for ItemIter<'a, T> {
         743  +
impl<T> Debug for ItemIter<'_, T> {
  744    744   
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  745    745   
        write!(f, "ItemIter")
  746    746   
    }
  747    747   
}
  748    748   
  749    749   
impl<'a, T: 'a> Iterator for ItemIter<'a, T>
  750    750   
where
  751    751   
    T: Store,
  752    752   
{
  753    753   
    type Item = &'a T::StoredType;

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-types/src/config_bag/storable.rs

@@ -56,56 +114,114 @@
   76     76   
        }
   77     77   
    }
   78     78   
}
   79     79   
   80     80   
/// Iterator of items returned by [`StoreAppend`]
   81     81   
pub struct AppendItemIter<'a, U> {
   82     82   
    inner: ItemIter<'a, StoreAppend<U>>,
   83     83   
    cur: Option<Rev<slice::Iter<'a, U>>>,
   84     84   
}
   85     85   
   86         -
impl<'a, U> Debug for AppendItemIter<'a, U> {
          86  +
impl<U> Debug for AppendItemIter<'_, U> {
   87     87   
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
   88     88   
        write!(f, "AppendItemIter")
   89     89   
    }
   90     90   
}
   91     91   
   92     92   
impl<'a, U: 'a> Iterator for AppendItemIter<'a, U>
   93     93   
where
   94     94   
    U: Send + Sync + Debug + 'static,
   95     95   
{
   96     96   
    type Item = &'a U;

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

@@ -1,1 +0,33 @@
   15     15   
   16     16   
[dependencies]
   17     17   
bytes = "1.10.0"
   18     18   
http = "1.0.0"
   19     19   
tracing = "0.1.40"
   20     20   
wasi = "0.12.1"
   21     21   
   22     22   
[dependencies.aws-smithy-runtime-api]
   23     23   
path = "../aws-smithy-runtime-api"
   24     24   
features = ["http-1x"]
   25         -
version = "1.8.0"
          25  +
version = "1.8.1"
   26     26   
   27     27   
[dependencies.aws-smithy-http]
   28     28   
path = "../aws-smithy-http"
   29     29   
version = "0.62.1"
   30     30   
   31     31   
[dependencies.aws-smithy-types]
   32     32   
path = "../aws-smithy-types"
   33         -
version = "1.3.1"
          33  +
version = "1.3.2"

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

@@ -1,1 +0,25 @@
    1      1   
# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
[package]
    3      3   
name = "aws-smithy-xml"
    4         -
version = "0.60.9"
           4  +
version = "0.60.10"
    5      5   
authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
    6      6   
description = "XML parsing logic for Smithy protocols."
    7      7   
edition = "2021"
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/smithy-lang/smithy-rs"
   10     10   
[package.metadata.docs.rs]
   11     11   
all-features = true
   12     12   
targets = ["x86_64-unknown-linux-gnu"]
   13     13   
cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"]
   14     14   
rustdoc-args = ["--cfg", "docsrs"]
   15     15   
   16     16   
[dependencies]
   17     17   
xmlparser = "0.13.5"
   18     18   
   19     19   
[dev-dependencies]
   20     20   
base64 = "0.13.0"
   21     21   
proptest = "1"
   22     22   
   23     23   
[dev-dependencies.aws-smithy-protocol-test]
   24     24   
path = "../aws-smithy-protocol-test"
   25         -
version = "0.63.2"
          25  +
version = "0.63.4"

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-xml/src/decode.rs

@@ -325,325 +385,385 @@
  345    345   
  346    346   
    fn nested_decoder<'a>(&'a mut self, start_el: StartEl<'inp>) -> ScopedDecoder<'inp, 'a> {
  347    347   
        ScopedDecoder {
  348    348   
            doc: self.doc,
  349    349   
            start_el,
  350    350   
            terminated: false,
  351    351   
        }
  352    352   
    }
  353    353   
}
  354    354   
  355         -
impl<'inp, 'a> Iterator for ScopedDecoder<'inp, 'a> {
         355  +
impl<'inp> Iterator for ScopedDecoder<'inp, '_> {
  356    356   
    type Item = Result<(XmlToken<'inp>, Depth), XmlDecodeError>;
  357    357   
  358    358   
    fn next(&mut self) -> Option<Self::Item> {
  359    359   
        if self.start_el.closed {
  360    360   
            self.terminated = true;
  361    361   
        }
  362    362   
        if self.terminated {
  363    363   
            return None;
  364    364   
        }
  365    365   
        let (tok, depth) = match self.doc.next() {

tmp-codegen-diff/aws-sdk/sdk/aws-smithy-xml/src/encode.rs

@@ -33,33 +93,93 @@
   53     53   
pub struct XmlWriter<'a> {
   54     54   
    doc: &'a mut String,
   55     55   
}
   56     56   
   57     57   
impl<'a> XmlWriter<'a> {
   58     58   
    pub fn new(doc: &'a mut String) -> Self {
   59     59   
        Self { doc }
   60     60   
    }
   61     61   
}
   62     62   
   63         -
impl<'a> XmlWriter<'a> {
          63  +
impl XmlWriter<'_> {
   64     64   
    pub fn start_el<'b, 'c>(&'c mut self, tag: &'b str) -> ElWriter<'c, 'b> {
   65     65   
        write!(self.doc, "<{}", tag).unwrap();
   66     66   
        ElWriter::new(self.doc, tag)
   67     67   
    }
   68     68   
}
   69     69   
   70     70   
pub struct ElWriter<'a, 'b> {
   71     71   
    start: &'b str,
   72     72   
    doc: Option<&'a mut String>,
   73     73   
}

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

@@ -7,7 +69,69 @@
   27     27   
[dependencies.aws-credential-types]
   28     28   
path = "../aws-credential-types"
   29     29   
version = "1.2.3"
   30     30   
   31     31   
[dependencies.aws-smithy-async]
   32     32   
path = "../aws-smithy-async"
   33     33   
version = "1.2.5"
   34     34   
   35     35   
[dependencies.aws-smithy-types]
   36     36   
path = "../aws-smithy-types"
   37         -
version = "1.3.1"
          37  +
version = "1.3.2"
   38     38   
   39     39   
[dependencies.aws-smithy-runtime]
   40     40   
path = "../aws-smithy-runtime"
   41     41   
optional = true
   42     42   
version = "1.8.3"
   43     43   
   44     44   
[dependencies.aws-smithy-runtime-api]
   45     45   
path = "../aws-smithy-runtime-api"
   46     46   
features = ["client"]
   47         -
version = "1.8.0"
          47  +
version = "1.8.1"
   48     48   
   49     49   
[dependencies.hyper-rustls]
   50     50   
version = "0.24"
   51     51   
optional = true
   52     52   
features = ["rustls-native-certs", "http2", "webpki-roots"]
   53     53   
   54     54   
[dev-dependencies]
   55     55   
http = "0.2.4"
   56     56   
tempfile = "3.16.0"
   57     57   
tracing-test = "0.2.5"
   58     58   
   59     59   
[dev-dependencies.tokio]
   60     60   
version = "1"
   61     61   
features = ["rt", "macros"]
   62     62   
   63     63   
[dev-dependencies.aws-smithy-runtime-api]
   64     64   
path = "../aws-smithy-runtime-api"
   65     65   
features = ["http-02x"]
   66         -
version = "1.8.0"
          66  +
version = "1.8.1"
   67     67   
   68     68   
[build-dependencies]
   69     69   
rustc_version = "0.4.0"

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

@@ -1,1 +95,95 @@
    1      1   
# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
[package]
    3      3   
name = "aws-sdk-bedrockruntime"
    4      4   
version = "0.0.0-local"
    5      5   
authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
    6      6   
description = "AWS SDK for Amazon Bedrock Runtime"
    7      7   
edition = "2021"
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/awslabs/aws-sdk-rust"
   10         -
rust-version = "1.82.0"
          10  +
rust-version = "1.85.0"
   11     11   
readme = "README.md"
   12     12   
[package.metadata.smithy]
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19     19   
version = "1.2.3"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23     23   
features = ["event-stream"]
   24         -
version = "1.5.7"
          24  +
version = "1.5.8"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.5"
   29     29   
   30     30   
[dependencies.aws-smithy-eventstream]
   31     31   
path = "../aws-smithy-eventstream"
   32         -
version = "0.60.8"
          32  +
version = "0.60.9"
   33     33   
   34     34   
[dependencies.aws-smithy-http]
   35     35   
path = "../aws-smithy-http"
   36     36   
features = ["event-stream"]
   37     37   
version = "0.62.1"
   38     38   
   39     39   
[dependencies.aws-smithy-json]
   40     40   
path = "../aws-smithy-json"
   41         -
version = "0.61.3"
          41  +
version = "0.61.4"
   42     42   
   43     43   
[dependencies.aws-smithy-runtime]
   44     44   
path = "../aws-smithy-runtime"
   45     45   
features = ["client"]
   46     46   
version = "1.8.3"
   47     47   
   48     48   
[dependencies.aws-smithy-runtime-api]
   49     49   
path = "../aws-smithy-runtime-api"
   50     50   
features = ["client", "http-02x"]
   51         -
version = "1.8.0"
          51  +
version = "1.8.1"
   52     52   
   53     53   
[dependencies.aws-smithy-types]
   54     54   
path = "../aws-smithy-types"
   55         -
version = "1.3.1"
          55  +
version = "1.3.2"
   56     56   
   57     57   
[dependencies.aws-types]
   58     58   
path = "../aws-types"
   59     59   
version = "1.3.7"
   60     60   
   61     61   
[dependencies.bytes]
   62     62   
version = "1.4.0"
   63     63   
   64     64   
[dependencies.fastrand]
   65     65   
version = "2.0.0"
   66     66   
   67     67   
[dependencies.http]
   68     68   
version = "0.2.9"
   69     69   
   70     70   
[dependencies.regex-lite]
   71     71   
version = "0.1.5"
   72     72   
   73     73   
[dependencies.tracing]
   74     74   
version = "0.1"
   75     75   
[dev-dependencies.aws-config]
   76     76   
path = "../aws-config"
   77         -
version = "1.6.3"
          77  +
version = "1.6.4"
   78     78   
   79     79   
[dev-dependencies.aws-credential-types]
   80     80   
path = "../aws-credential-types"
   81     81   
features = ["test-util"]
   82     82   
version = "1.2.3"
   83     83   
   84     84   
[dev-dependencies.tokio]
   85     85   
version = "1.23.1"
   86     86   
features = ["macros", "test-util", "rt-multi-thread"]
   87     87

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/config.rs

@@ -235,235 +329,330 @@
  255    255   
    /// let config = builder.build();
  256    256   
    /// # }
  257    257   
    /// # }
  258    258   
    /// ```
  259    259   
    pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
  260    260   
        self.runtime_components.set_http_client(http_client);
  261    261   
        self
  262    262   
    }
  263    263   
    /// Sets the endpoint resolver to use when making requests.
  264    264   
    ///
  265         -
         265  +
    ///
  266    266   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  267    267   
    /// rules for `aws_sdk_bedrockruntime`.
  268         -
         268  +
    ///
  269    269   
    ///
  270    270   
    /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
  271    271   
    /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
  272    272   
    /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
  273    273   
    ///
  274    274   
    /// # Examples
  275    275   
    /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
  276    276   
    /// ```no_run
  277    277   
    /// use aws_sdk_bedrockruntime::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
  278    278   
    /// #[derive(Debug)]
  279    279   
    /// struct StageResolver { stage: String }
  280    280   
    /// impl ResolveEndpoint for StageResolver {
  281    281   
    ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
  282    282   
    ///         let stage = &self.stage;
  283    283   
    ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
  284    284   
    ///     }
  285    285   
    /// }
  286    286   
    /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
  287    287   
    /// let config = aws_sdk_bedrockruntime::Config::builder().endpoint_resolver(resolver).build();
  288    288   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
  289    289   
    /// ```
  290    290   
    pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
  291    291   
        self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
  292    292   
        self
  293    293   
    }
  294    294   
  295    295   
    /// Sets the endpoint resolver to use when making requests.
  296    296   
    ///
  297         -
         297  +
    ///
  298    298   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  299    299   
    /// rules for `aws_sdk_bedrockruntime`.
         300  +
    ///
  300    301   
    pub fn set_endpoint_resolver(
  301    302   
        &mut self,
  302    303   
        endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
  303    304   
    ) -> &mut Self {
  304    305   
        self.runtime_components.set_endpoint_resolver(endpoint_resolver);
  305    306   
        self
  306    307   
    }
  307    308   
    /// Set the retry_config for the builder
  308    309   
    ///
  309    310   
    /// # Examples
@@ -475,476 +581,582 @@
  495    496   
    ///     .identity_cache(
  496    497   
    ///         IdentityCache::lazy()
  497    498   
    ///             // change the load timeout to 10 seconds
  498    499   
    ///             .load_timeout(Duration::from_secs(10))
  499    500   
    ///             .build()
  500    501   
    ///     )
  501    502   
    ///     // ...
  502    503   
    ///     .build();
  503    504   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
  504    505   
    /// ```
  505         -
         506  +
    ///
  506    507   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  507    508   
        self.set_identity_cache(identity_cache);
  508    509   
        self
  509    510   
    }
  510    511   
  511    512   
    /// Set the identity cache for auth.
  512    513   
    ///
  513    514   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  514    515   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  515    516   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  516    517   
    /// the next request will result in refreshing the identity.
  517    518   
    ///
  518    519   
    /// This configuration allows you to disable or change the default caching mechanism.
  519    520   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  520    521   
    /// trait and pass that implementation into this function.
  521    522   
    ///
  522    523   
    /// # Examples
  523    524   
    ///
  524    525   
    /// Disabling identity caching:
  525    526   
    /// ```no_run
  526    527   
    /// use aws_sdk_bedrockruntime::config::IdentityCache;
  527    528   
    ///
  528    529   
    /// let config = aws_sdk_bedrockruntime::Config::builder()
  529    530   
    ///     .identity_cache(IdentityCache::no_cache())
  530    531   
    ///     // ...
  531    532   
    ///     .build();
  532    533   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
  533    534   
    /// ```
  534    535   
    ///
  535    536   
    /// Customizing lazy caching:
  536    537   
    /// ```no_run
  537    538   
    /// use aws_sdk_bedrockruntime::config::IdentityCache;
  538    539   
    /// use std::time::Duration;
  539    540   
    ///
  540    541   
    /// let config = aws_sdk_bedrockruntime::Config::builder()
  541    542   
    ///     .identity_cache(
  542    543   
    ///         IdentityCache::lazy()
  543    544   
    ///             // change the load timeout to 10 seconds
  544    545   
    ///             .load_timeout(Duration::from_secs(10))
  545    546   
    ///             .build()
  546    547   
    ///     )
  547    548   
    ///     // ...
  548    549   
    ///     .build();
  549    550   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
  550    551   
    /// ```
  551         -
         552  +
    ///
  552    553   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  553    554   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  554    555   
        self
  555    556   
    }
  556    557   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  557    558   
    ///
  558    559   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  559    560   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  560    561   
    /// will run after those default interceptors.
  561    562   
    ///
@@ -975,976 +1070,1071 @@
  995    996   
    /// Customizing behavior major version:
  996    997   
    /// ```no_run
  997    998   
    /// use aws_sdk_bedrockruntime::config::BehaviorVersion;
  998    999   
    ///
  999   1000   
    /// let config = aws_sdk_bedrockruntime::Config::builder()
 1000   1001   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
 1001   1002   
    ///     // ...
 1002   1003   
    ///     .build();
 1003   1004   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
 1004   1005   
    /// ```
 1005         -
        1006  +
    ///
 1006   1007   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
 1007   1008   
        self.set_behavior_version(Some(behavior_version));
 1008   1009   
        self
 1009   1010   
    }
 1010   1011   
 1011   1012   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
 1012   1013   
    ///
 1013   1014   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
 1014   1015   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
 1015   1016   
    /// all operations might be the ideal behavior but could break existing applications.
 1016   1017   
    ///
 1017   1018   
    /// # Examples
 1018   1019   
    ///
 1019   1020   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
 1020   1021   
    /// ```no_run
 1021   1022   
    /// use aws_sdk_bedrockruntime::config::BehaviorVersion;
 1022   1023   
    ///
 1023   1024   
    /// let config = aws_sdk_bedrockruntime::Config::builder()
 1024   1025   
    ///     .behavior_version(BehaviorVersion::latest())
 1025   1026   
    ///     // ...
 1026   1027   
    ///     .build();
 1027   1028   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
 1028   1029   
    /// ```
 1029   1030   
    ///
 1030   1031   
    /// Customizing behavior major version:
 1031   1032   
    /// ```no_run
 1032   1033   
    /// use aws_sdk_bedrockruntime::config::BehaviorVersion;
 1033   1034   
    ///
 1034   1035   
    /// let config = aws_sdk_bedrockruntime::Config::builder()
 1035   1036   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
 1036   1037   
    ///     // ...
 1037   1038   
    ///     .build();
 1038   1039   
    /// let client = aws_sdk_bedrockruntime::Client::from_conf(config);
 1039   1040   
    /// ```
 1040         -
        1041  +
    ///
 1041   1042   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
 1042   1043   
        self.behavior_version = behavior_version;
 1043   1044   
        self
 1044   1045   
    }
 1045   1046   
 1046   1047   
    /// Convenience method to set the latest behavior major version
 1047   1048   
    ///
 1048   1049   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
 1049   1050   
    pub fn behavior_version_latest(mut self) -> Self {
 1050   1051   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -1131,1132 +1191,1192 @@
 1151   1152   
    }
 1152   1153   
 1153   1154   
    fn runtime_components(
 1154   1155   
        &self,
 1155   1156   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1156   1157   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1157   1158   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1158   1159   
    }
 1159   1160   
}
 1160   1161   
 1161         -
/// Cross-operation shared-state singletons
        1162  +
// Cross-operation shared-state singletons
 1162   1163   
 1163   1164   
/// A plugin that enables configuration for a single operation invocation
 1164   1165   
///
 1165   1166   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1166   1167   
/// In the case of default values requested, they will be obtained from `client_config`.
 1167   1168   
#[derive(Debug)]
 1168   1169   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1169   1170   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1170   1171   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1171   1172   
}

tmp-codegen-diff/aws-sdk/sdk/bedrockruntime/src/endpoint_lib/partition.rs

@@ -13,13 +73,73 @@
   33     33   
pub(crate) struct Partition<'a> {
   34     34   
    name: &'a str,
   35     35   
    dns_suffix: &'a str,
   36     36   
    dual_stack_dns_suffix: &'a str,
   37     37   
    supports_fips: bool,
   38     38   
    supports_dual_stack: bool,
   39     39   
    implicit_global_region: &'a str,
   40     40   
}
   41     41   
   42     42   
#[allow(unused)]
   43         -
impl<'a> Partition<'a> {
          43  +
impl Partition<'_> {
   44     44   
    pub(crate) fn name(&self) -> &str {
   45     45   
        self.name
   46     46   
    }
   47     47   
   48     48   
    pub(crate) fn dns_suffix(&self) -> &str {
   49     49   
        self.dns_suffix
   50     50   
    }
   51     51   
   52     52   
    pub(crate) fn supports_fips(&self) -> bool {
   53     53   
        self.supports_fips

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

@@ -1,1 +150,150 @@
    1      1   
# Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
[package]
    3      3   
name = "aws-sdk-cloudwatchlogs"
    4      4   
version = "0.0.0-local"
    5      5   
authors = ["AWS Rust SDK Team <aws-sdk-rust@amazon.com>", "Russell Cohen <rcoh@amazon.com>"]
    6      6   
description = "AWS SDK for Amazon CloudWatch Logs"
    7      7   
edition = "2021"
    8      8   
license = "Apache-2.0"
    9      9   
repository = "https://github.com/awslabs/aws-sdk-rust"
   10         -
rust-version = "1.82.0"
          10  +
rust-version = "1.85.0"
   11     11   
readme = "README.md"
   12     12   
[package.metadata.smithy]
   13     13   
codegen-version = "ci"
   14     14   
[package.metadata.docs.rs]
   15     15   
all-features = true
   16     16   
targets = ["x86_64-unknown-linux-gnu"]
   17     17   
[dependencies.aws-credential-types]
   18     18   
path = "../aws-credential-types"
   19     19   
version = "1.2.3"
   20     20   
   21     21   
[dependencies.aws-runtime]
   22     22   
path = "../aws-runtime"
   23     23   
features = ["event-stream"]
   24         -
version = "1.5.7"
          24  +
version = "1.5.8"
   25     25   
   26     26   
[dependencies.aws-smithy-async]
   27     27   
path = "../aws-smithy-async"
   28     28   
version = "1.2.5"
   29     29   
   30     30   
[dependencies.aws-smithy-eventstream]
   31     31   
path = "../aws-smithy-eventstream"
   32         -
version = "0.60.8"
          32  +
version = "0.60.9"
   33     33   
   34     34   
[dependencies.aws-smithy-http]
   35     35   
path = "../aws-smithy-http"
   36     36   
features = ["event-stream"]
   37     37   
version = "0.62.1"
   38     38   
   39     39   
[dependencies.aws-smithy-json]
   40     40   
path = "../aws-smithy-json"
   41         -
version = "0.61.3"
          41  +
version = "0.61.4"
   42     42   
   43     43   
[dependencies.aws-smithy-runtime]
   44     44   
path = "../aws-smithy-runtime"
   45     45   
features = ["client"]
   46     46   
version = "1.8.3"
   47     47   
   48     48   
[dependencies.aws-smithy-runtime-api]
   49     49   
path = "../aws-smithy-runtime-api"
   50     50   
features = ["client", "http-02x"]
   51         -
version = "1.8.0"
          51  +
version = "1.8.1"
   52     52   
   53     53   
[dependencies.aws-smithy-types]
   54     54   
path = "../aws-smithy-types"
   55         -
version = "1.3.1"
          55  +
version = "1.3.2"
   56     56   
   57     57   
[dependencies.aws-types]
   58     58   
path = "../aws-types"
   59     59   
version = "1.3.7"
   60     60   
   61     61   
[dependencies.bytes]
   62     62   
version = "1.4.0"
   63     63   
   64     64   
[dependencies.fastrand]
   65     65   
version = "2.0.0"
   66     66   
   67     67   
[dependencies.http]
   68     68   
version = "0.2.9"
   69     69   
   70     70   
[dependencies.regex-lite]
   71     71   
version = "0.1.5"
   72     72   
   73     73   
[dependencies.tracing]
   74     74   
version = "0.1"
   75     75   
[dev-dependencies.aws-config]
   76     76   
path = "../aws-config"
   77         -
version = "1.6.3"
          77  +
version = "1.6.4"
   78     78   
   79     79   
[dev-dependencies.aws-credential-types]
   80     80   
path = "../aws-credential-types"
   81     81   
features = ["test-util"]
   82     82   
version = "1.2.3"
   83     83   
   84     84   
[dev-dependencies.aws-runtime]
   85     85   
path = "../aws-runtime"
   86     86   
features = ["test-util"]
   87         -
version = "1.5.7"
          87  +
version = "1.5.8"
   88     88   
   89     89   
[dev-dependencies.aws-smithy-async]
   90     90   
path = "../aws-smithy-async"
   91     91   
features = ["test-util"]
   92     92   
version = "1.2.5"
   93     93   
   94     94   
[dev-dependencies.aws-smithy-eventstream]
   95     95   
path = "../aws-smithy-eventstream"
   96     96   
features = ["test-util"]
   97         -
version = "0.60.8"
          97  +
version = "0.60.9"
   98     98   
   99     99   
[dev-dependencies.aws-smithy-http-client]
  100    100   
path = "../aws-smithy-http-client"
  101    101   
features = ["test-util", "wire-mock"]
  102         -
version = "1.0.3"
         102  +
version = "1.0.5"
  103    103   
  104    104   
[dev-dependencies.aws-smithy-protocol-test]
  105    105   
path = "../aws-smithy-protocol-test"
  106         -
version = "0.63.2"
         106  +
version = "0.63.4"
  107    107   
  108    108   
[dev-dependencies.aws-smithy-runtime]
  109    109   
path = "../aws-smithy-runtime"
  110    110   
features = ["test-util"]
  111    111   
version = "1.8.3"
  112    112   
  113    113   
[dev-dependencies.aws-smithy-runtime-api]
  114    114   
path = "../aws-smithy-runtime-api"
  115    115   
features = ["test-util"]
  116         -
version = "1.8.0"
         116  +
version = "1.8.1"
  117    117   
  118    118   
[dev-dependencies.aws-smithy-types]
  119    119   
path = "../aws-smithy-types"
  120    120   
features = ["test-util"]
  121         -
version = "1.3.1"
         121  +
version = "1.3.2"
  122    122   
  123    123   
[dev-dependencies.futures-util]
  124    124   
version = "0.3.25"
  125    125   
features = ["alloc"]
  126    126   
default-features = false
  127    127   
  128    128   
[dev-dependencies.http-1x]
  129    129   
version = "1"
  130    130   
package = "http"
  131    131

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

@@ -251,251 +345,346 @@
  271    271   
    /// let config = builder.build();
  272    272   
    /// # }
  273    273   
    /// # }
  274    274   
    /// ```
  275    275   
    pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
  276    276   
        self.runtime_components.set_http_client(http_client);
  277    277   
        self
  278    278   
    }
  279    279   
    /// Sets the endpoint resolver to use when making requests.
  280    280   
    ///
  281         -
         281  +
    ///
  282    282   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  283    283   
    /// rules for `aws_sdk_cloudwatchlogs`.
  284         -
         284  +
    ///
  285    285   
    ///
  286    286   
    /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
  287    287   
    /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
  288    288   
    /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
  289    289   
    ///
  290    290   
    /// # Examples
  291    291   
    /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
  292    292   
    /// ```no_run
  293    293   
    /// use aws_sdk_cloudwatchlogs::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
  294    294   
    /// #[derive(Debug)]
  295    295   
    /// struct StageResolver { stage: String }
  296    296   
    /// impl ResolveEndpoint for StageResolver {
  297    297   
    ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
  298    298   
    ///         let stage = &self.stage;
  299    299   
    ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
  300    300   
    ///     }
  301    301   
    /// }
  302    302   
    /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
  303    303   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder().endpoint_resolver(resolver).build();
  304    304   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
  305    305   
    /// ```
  306    306   
    pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
  307    307   
        self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
  308    308   
        self
  309    309   
    }
  310    310   
  311    311   
    /// Sets the endpoint resolver to use when making requests.
  312    312   
    ///
  313         -
         313  +
    ///
  314    314   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  315    315   
    /// rules for `aws_sdk_cloudwatchlogs`.
         316  +
    ///
  316    317   
    pub fn set_endpoint_resolver(
  317    318   
        &mut self,
  318    319   
        endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
  319    320   
    ) -> &mut Self {
  320    321   
        self.runtime_components.set_endpoint_resolver(endpoint_resolver);
  321    322   
        self
  322    323   
    }
  323    324   
    /// Set the retry_config for the builder
  324    325   
    ///
  325    326   
    /// # Examples
@@ -491,492 +597,598 @@
  511    512   
    ///     .identity_cache(
  512    513   
    ///         IdentityCache::lazy()
  513    514   
    ///             // change the load timeout to 10 seconds
  514    515   
    ///             .load_timeout(Duration::from_secs(10))
  515    516   
    ///             .build()
  516    517   
    ///     )
  517    518   
    ///     // ...
  518    519   
    ///     .build();
  519    520   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
  520    521   
    /// ```
  521         -
         522  +
    ///
  522    523   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  523    524   
        self.set_identity_cache(identity_cache);
  524    525   
        self
  525    526   
    }
  526    527   
  527    528   
    /// Set the identity cache for auth.
  528    529   
    ///
  529    530   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  530    531   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  531    532   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  532    533   
    /// the next request will result in refreshing the identity.
  533    534   
    ///
  534    535   
    /// This configuration allows you to disable or change the default caching mechanism.
  535    536   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  536    537   
    /// trait and pass that implementation into this function.
  537    538   
    ///
  538    539   
    /// # Examples
  539    540   
    ///
  540    541   
    /// Disabling identity caching:
  541    542   
    /// ```no_run
  542    543   
    /// use aws_sdk_cloudwatchlogs::config::IdentityCache;
  543    544   
    ///
  544    545   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder()
  545    546   
    ///     .identity_cache(IdentityCache::no_cache())
  546    547   
    ///     // ...
  547    548   
    ///     .build();
  548    549   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
  549    550   
    /// ```
  550    551   
    ///
  551    552   
    /// Customizing lazy caching:
  552    553   
    /// ```no_run
  553    554   
    /// use aws_sdk_cloudwatchlogs::config::IdentityCache;
  554    555   
    /// use std::time::Duration;
  555    556   
    ///
  556    557   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder()
  557    558   
    ///     .identity_cache(
  558    559   
    ///         IdentityCache::lazy()
  559    560   
    ///             // change the load timeout to 10 seconds
  560    561   
    ///             .load_timeout(Duration::from_secs(10))
  561    562   
    ///             .build()
  562    563   
    ///     )
  563    564   
    ///     // ...
  564    565   
    ///     .build();
  565    566   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
  566    567   
    /// ```
  567         -
         568  +
    ///
  568    569   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  569    570   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  570    571   
        self
  571    572   
    }
  572    573   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  573    574   
    ///
  574    575   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  575    576   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  576    577   
    /// will run after those default interceptors.
  577    578   
    ///
@@ -991,992 +1086,1087 @@
 1011   1012   
    /// Customizing behavior major version:
 1012   1013   
    /// ```no_run
 1013   1014   
    /// use aws_sdk_cloudwatchlogs::config::BehaviorVersion;
 1014   1015   
    ///
 1015   1016   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder()
 1016   1017   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
 1017   1018   
    ///     // ...
 1018   1019   
    ///     .build();
 1019   1020   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
 1020   1021   
    /// ```
 1021         -
        1022  +
    ///
 1022   1023   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
 1023   1024   
        self.set_behavior_version(Some(behavior_version));
 1024   1025   
        self
 1025   1026   
    }
 1026   1027   
 1027   1028   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
 1028   1029   
    ///
 1029   1030   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
 1030   1031   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
 1031   1032   
    /// all operations might be the ideal behavior but could break existing applications.
 1032   1033   
    ///
 1033   1034   
    /// # Examples
 1034   1035   
    ///
 1035   1036   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
 1036   1037   
    /// ```no_run
 1037   1038   
    /// use aws_sdk_cloudwatchlogs::config::BehaviorVersion;
 1038   1039   
    ///
 1039   1040   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder()
 1040   1041   
    ///     .behavior_version(BehaviorVersion::latest())
 1041   1042   
    ///     // ...
 1042   1043   
    ///     .build();
 1043   1044   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
 1044   1045   
    /// ```
 1045   1046   
    ///
 1046   1047   
    /// Customizing behavior major version:
 1047   1048   
    /// ```no_run
 1048   1049   
    /// use aws_sdk_cloudwatchlogs::config::BehaviorVersion;
 1049   1050   
    ///
 1050   1051   
    /// let config = aws_sdk_cloudwatchlogs::Config::builder()
 1051   1052   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
 1052   1053   
    ///     // ...
 1053   1054   
    ///     .build();
 1054   1055   
    /// let client = aws_sdk_cloudwatchlogs::Client::from_conf(config);
 1055   1056   
    /// ```
 1056         -
        1057  +
    ///
 1057   1058   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
 1058   1059   
        self.behavior_version = behavior_version;
 1059   1060   
        self
 1060   1061   
    }
 1061   1062   
 1062   1063   
    /// Convenience method to set the latest behavior major version
 1063   1064   
    ///
 1064   1065   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
 1065   1066   
    pub fn behavior_version_latest(mut self) -> Self {
 1066   1067   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -1149,1150 +1209,1210 @@
 1169   1170   
    }
 1170   1171   
 1171   1172   
    fn runtime_components(
 1172   1173   
        &self,
 1173   1174   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1174   1175   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1175   1176   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1176   1177   
    }
 1177   1178   
}
 1178   1179   
 1179         -
/// Cross-operation shared-state singletons
        1180  +
// Cross-operation shared-state singletons
 1180   1181   
 1181   1182   
/// A plugin that enables configuration for a single operation invocation
 1182   1183   
///
 1183   1184   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1184   1185   
/// In the case of default values requested, they will be obtained from `client_config`.
 1185   1186   
#[derive(Debug)]
 1186   1187   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1187   1188   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1188   1189   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1189   1190   
}