Client Test

tmp-codegen-diff/codegen-client-test/Cargo.lock

@@ -296,296 +748,748 @@

  "untrusted 0.7.1",
  "zeroize",
-298
+]
-299
 [[package]]
 name = "aws-lc-sys"
 version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "61b1d86e7705efe1be1b569bab41d4fa1e14e220b60a160f78de2db687add079"
 dependencies = [
  "bindgen",
  "cc",
  "cmake",
  "dunce",
  "fs_extra",
-311
+]
-312
 [[package]]
 name = "aws-smithy-async"
 version = "1.2.5"

 dependencies = [
  "futures-util",
  "pin-project-lite",
  "pin-utils",
  "tokio",
  "tokio-test",
-322
+]
-323
 [[package]]
 name = "aws-smithy-cbor"
 version = "0.61.0"
 version = "0.61.1"
 dependencies = [
  "aws-smithy-types",
  "criterion",
  "minicbor",
-331
+]
-332
 [[package]]
 name = "aws-smithy-checksums"
 version = "0.63.3"
 dependencies = [
  "aws-smithy-http",
  "aws-smithy-types",
  "bytes",
  "bytes-utils",
  "crc-fast",
  "hex",
  "http 0.2.12",
  "http-body 0.4.6",
  "md-5",
  "pin-project-lite",
  "pretty_assertions",
  "sha1",
  "sha2",
  "tokio",
  "tracing",
  "tracing-test",
-353
+]
-354
 [[package]]
 name = "aws-smithy-client"
 version = "0.60.3"
-358
 [[package]]
 name = "aws-smithy-compression"
 version = "0.0.3"
 version = "0.0.4"
 dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "bytes-utils",
  "flate2",
  "futures-util",
  "http 0.2.12",
  "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "http-body-util",
  "pin-project-lite",
  "pretty_assertions",
  "tokio",
  "tracing",
-378
+]
-379
 [[package]]
 name = "aws-smithy-eventstream"
 version = "0.60.8"
 version = "0.60.9"
 dependencies = [
  "arbitrary",
  "aws-smithy-types",
  "bytes",
  "bytes-utils",
  "crc32fast",
  "derive_arbitrary",
-390
+]
-391
 [[package]]
 name = "aws-smithy-experimental"
 version = "0.2.0"
-395
 [[package]]
 name = "aws-smithy-http"
 version = "0.62.1"
 dependencies = [
  "async-stream",
  "aws-smithy-eventstream",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "bytes-utils",
  "futures-core",
  "futures-util",
  "http 0.2.12",
  "http 1.3.1",
  "http-body 0.4.6",
  "hyper 0.14.32",
  "percent-encoding",
  "pin-project-lite",
  "pin-utils",
  "proptest",
  "tokio",
  "tracing",
-418
+]
-419
 [[package]]
 name = "aws-smithy-http-auth"
 version = "0.60.3"
-423
 [[package]]
 name = "aws-smithy-http-client"
 version = "1.0.3"
 version = "1.0.5"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-protocol-test",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "h2 0.3.26",
  "h2 0.4.10",
  "http 0.2.12",
  "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "http-body-util",
  "hyper 0.14.32",
  "hyper 1.6.0",
  "hyper-rustls 0.24.2",
  "hyper-rustls 0.27.6",
  "hyper-util",
  "indexmap 2.9.0",
  "pin-project-lite",
  "rustls 0.21.12",
  "rustls 0.23.27",
  "rustls-native-certs 0.8.1",
  "rustls-pemfile 2.2.0",
  "rustls-pki-types",
  "s2n-tls",
  "s2n-tls-hyper",
  "serde",
  "serde_json",
  "tokio",
  "tokio-rustls 0.26.2",
  "tower 0.5.2",
  "tracing",
-460
+]
-461
 [[package]]
 name = "aws-smithy-http-server"
 version = "0.65.3"
 version = "0.65.5"
 dependencies = [
  "aws-smithy-cbor",
  "aws-smithy-http",
  "aws-smithy-json",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "aws-smithy-xml",
  "bytes",
  "futures-util",
  "http 0.2.12",
  "http-body 0.4.6",
  "hyper 0.14.32",
  "lambda_http",
  "mime",
  "nom",
  "pin-project-lite",
  "pretty_assertions",
  "regex",
  "serde_urlencoded",
  "thiserror 2.0.12",
  "tokio",
  "tower 0.4.13",
  "tower-http",
  "tracing",
  "uuid",
-490
+]
-491
 [[package]]
 name = "aws-smithy-http-server-python"
 version = "0.66.0"
 version = "0.66.1"
 dependencies = [
  "aws-smithy-http",
  "aws-smithy-http-server",
  "aws-smithy-json",
  "aws-smithy-types",
  "aws-smithy-xml",
  "bytes",
  "futures",
  "futures-util",
  "http 0.2.12",
  "hyper 0.14.32",
  "hyper-rustls 0.24.2",
  "lambda_http",
  "num_cpus",
  "parking_lot",
  "pin-project-lite",
  "pretty_assertions",
  "pyo3",
  "pyo3-asyncio",
  "rcgen",
  "rustls-pemfile 1.0.4",
  "signal-hook",
  "socket2",
  "thiserror 2.0.12",
  "tls-listener",
  "tokio",
  "tokio-rustls 0.24.1",
  "tokio-stream",
  "tokio-test",
  "tower 0.4.13",
  "tower-test",
  "tracing",
  "tracing-appender",
  "tracing-subscriber",
-529
+]
-530
 [[package]]
 name = "aws-smithy-http-tower"
 version = "0.60.3"
-534
 [[package]]
 name = "aws-smithy-json"
 version = "0.61.3"
 version = "0.61.4"
 dependencies = [
  "aws-smithy-types",
  "proptest",
  "serde_json",
-542
+]
-543
 [[package]]
 name = "aws-smithy-mocks"
 version = "0.1.1"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-http-client",
  "aws-smithy-runtime",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "http 1.3.1",
  "tokio",
-555
+]
-556
 [[package]]
 name = "aws-smithy-mocks-experimental"
 version = "0.2.4"
 dependencies = [
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "tokio",
-564
+]
-565
 [[package]]
 name = "aws-smithy-observability"
 version = "0.1.3"
 dependencies = [
  "aws-smithy-runtime-api",
  "serial_test",
-572
+]
-573
 [[package]]
 name = "aws-smithy-observability-otel"
 version = "0.1.0"
 version = "0.1.1"
 dependencies = [
  "async-global-executor",
  "async-task",
  "aws-smithy-observability",
  "criterion",
  "opentelemetry",
  "opentelemetry_sdk",
  "stats_alloc",
  "tokio",
  "value-bag",
-587
+]
-588
 [[package]]
 name = "aws-smithy-protocol-test"
 version = "0.63.2"
 version = "0.63.4"
 dependencies = [
  "assert-json-diff",
  "aws-smithy-runtime-api",
  "base64-simd",
  "cbor-diag",
  "ciborium",
  "http 0.2.12",
  "pretty_assertions",
  "regex-lite",
  "roxmltree",
  "serde_json",
  "thiserror 2.0.12",
-604
+]
-605
 [[package]]
 name = "aws-smithy-query"
 version = "0.60.7"
 dependencies = [
  "aws-smithy-types",
  "urlencoding",
-612
+]
-613
 [[package]]
 name = "aws-smithy-runtime"
 version = "1.8.3"
 dependencies = [
  "approx",
  "aws-smithy-async",
  "aws-smithy-http",
  "aws-smithy-http-client",
  "aws-smithy-observability",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "fastrand",
  "futures-util",
  "http 0.2.12",
  "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "hyper 0.14.32",
  "pin-project-lite",
  "pin-utils",
  "pretty_assertions",
  "tokio",
  "tracing",
  "tracing-subscriber",
  "tracing-test",
-640
+]
-641
 [[package]]
 name = "aws-smithy-runtime-api"
 version = "1.8.0"
 version = "1.8.1"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
  "bytes",
  "http 0.2.12",
  "http 1.3.1",
  "pin-project-lite",
  "proptest",
  "tokio",
  "tracing",
  "zeroize",
-656
+]
-657
 [[package]]
 name = "aws-smithy-types"
 version = "1.3.1"
 version = "1.3.2"
 dependencies = [
  "base64 0.13.1",
  "base64-simd",
  "bytes",
  "bytes-utils",
  "ciborium",
  "criterion",
  "futures-core",
  "http 0.2.12",
  "http 1.3.1",
  "http-body 0.4.6",
  "http-body 1.0.1",
  "http-body-util",
  "hyper 0.14.32",
  "itoa",
  "lazy_static",
  "num-integer",
  "pin-project-lite",
  "pin-utils",
  "proptest",
  "rand 0.8.5",
  "ryu",
  "serde",
  "serde_json",
  "tempfile",
  "time",
  "tokio",
  "tokio-stream",
  "tokio-util",
-690
+]
-691
 [[package]]
 name = "aws-smithy-types-convert"
 version = "0.60.9"
 dependencies = [
  "aws-smithy-async",
  "aws-smithy-types",
  "chrono",
  "futures-core",
  "time",
-701
+]
-702
 [[package]]
 name = "aws-smithy-wasm"
 version = "0.1.4"
 dependencies = [
  "aws-smithy-http",
  "aws-smithy-runtime-api",
  "aws-smithy-types",
  "bytes",
  "http 1.3.1",
  "tracing",
  "wasi 0.12.1+wasi-0.2.0",
-714
+]
-715
 [[package]]
 name = "aws-smithy-xml"
 version = "0.60.9"
 version = "0.60.10"
 dependencies = [
  "aws-smithy-protocol-test",
  "base64 0.13.1",
  "proptest",
  "xmlparser",
-724
+]
-725
 [[package]]
 name = "aws_lambda_events"
 version = "0.12.1"

↧ Expand context

 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "03611508dd1e514e311caec235b581c99a4cb66fa1771bd502819eed69894f12"
 dependencies = [
  "base64 0.21.7",
  "bytes",
  "http 0.2.12",
  "http-body 0.4.6",
  "http-serde",
  "query_map",
  "serde",
  "serde_json",
-740
+]
-741
 [[package]]
 name = "backtrace"
 version = "0.3.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6806a6321ec58106fea15becdad98371e28d92ccbc7c8f1b3b6dd724fe8f1002"
 dependencies = [
  "addr2line",

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use aws_query::config::IdentityCache;
     ///
     /// let config = aws_query::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use aws_query::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = aws_query::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-492
+    }
-493
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use aws_query::config::IdentityCache;
     ///
     /// let config = aws_query::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use aws_query::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = aws_query::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-538
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use aws_query::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -850,850 +945,945 @@

↥ Expand context

-850
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use aws_query::config::BehaviorVersion;
     ///
     /// let config = aws_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use aws_query::config::BehaviorVersion;
     ///
     /// let config = aws_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-884
+    }
-885
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use aws_query::config::BehaviorVersion;
     ///
     /// let config = aws_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use aws_query::config::BehaviorVersion;
     ///
     /// let config = aws_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = aws_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-919
+    }
-920
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-927
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-932
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-937
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));

@@ -982,982 +1042,1042 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("AwsQuery");
             cfg.store_put(crate::idempotency_token::default_provider());
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-992
+    }
-993
+}
-994
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-998
+    }
-999
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-1002
+    }
-1003
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1009
+    }
-1010
+}
-1011
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-1013
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1022
+}

↧ Expand context

-1023
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1036
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("aws_query::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use dynamo::config::IdentityCache;
     ///
     /// let config = dynamo::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use dynamo::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = dynamo::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-492
+    }
-493
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use dynamo::config::IdentityCache;
     ///
     /// let config = dynamo::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use dynamo::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = dynamo::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-538
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use dynamo::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -850,850 +945,945 @@

↥ Expand context

-850
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use dynamo::config::BehaviorVersion;
     ///
     /// let config = dynamo::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use dynamo::config::BehaviorVersion;
     ///
     /// let config = dynamo::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-884
+    }
-885
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use dynamo::config::BehaviorVersion;
     ///
     /// let config = dynamo::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use dynamo::config::BehaviorVersion;
     ///
     /// let config = dynamo::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = dynamo::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-919
+    }
-920
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-927
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-932
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-937
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));

@@ -982,982 +1042,1042 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DynamoDB_20120810");
             cfg.store_put(crate::idempotency_token::default_provider());
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-992
+    }
-993
+}
-994
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-998
+    }
-999
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-1002
+    }
-1003
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1009
+    }
-1010
+}
-1011
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-1013
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1022
+}

↧ Expand context

-1023
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1036
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("dynamo::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/lens.rs

@@ -25,25 +80,71 @@

↥ Expand context

     let input = match &input.last_evaluated_table_name {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     ::std::option::Option::Some(input)
-30
+}
-31
 pub(crate) fn reflens_query_output_output_last_evaluated_key(
     input: &crate::operation::query::QueryOutput,
 ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {
     let input = match &input.last_evaluated_key {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     ::std::option::Option::Some(input)
-40
+}
-41
 pub(crate) fn reflens_scan_output_output_last_evaluated_key(
     input: &crate::operation::scan::ScanOutput,
 ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>> {

     let input = match &input.last_evaluated_key {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     ::std::option::Option::Some(input)
-50
+}
-51
 pub(crate) fn lens_list_tables_output_output_table_names(
     input: crate::operation::list_tables::ListTablesOutput,
 ) -> ::std::option::Option<::std::vec::Vec<::std::string::String>> {
     let input = match input.table_names {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     let input = input.table_names?;
     ::std::option::Option::Some(input)
-57
+}
-58
 pub(crate) fn lens_query_output_output_items(
     input: crate::operation::query::QueryOutput,
 ) -> ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>> {
     let input = match input.items {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     let input = input.items?;
     ::std::option::Option::Some(input)
-64
+}
-65
 pub(crate) fn lens_scan_output_output_items(
     input: crate::operation::scan::ScanOutput,
 ) -> ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>> {
     let input = match input.items {
         ::std::option::Option::None => return ::std::option::Option::None,
         ::std::option::Option::Some(t) => t,
     };
     let input = input.items?;
     ::std::option::Option::Some(input)
-71
+}

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use ebs::config::IdentityCache;
     ///
     /// let config = ebs::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use ebs::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = ebs::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-492
+    }
-493
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use ebs::config::IdentityCache;
     ///
     /// let config = ebs::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use ebs::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = ebs::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-538
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use ebs::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -850,850 +945,945 @@

↥ Expand context

-850
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use ebs::config::BehaviorVersion;
     ///
     /// let config = ebs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use ebs::config::BehaviorVersion;
     ///
     /// let config = ebs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-884
+    }
-885
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use ebs::config::BehaviorVersion;
     ///
     /// let config = ebs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use ebs::config::BehaviorVersion;
     ///
     /// let config = ebs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = ebs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-919
+    }
-920
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-927
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-932
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-937
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));

@@ -982,982 +1042,1042 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Ebs");
             cfg.store_put(crate::idempotency_token::default_provider());
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-992
+    }
-993
+}
-994
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-998
+    }
-999
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-1002
+    }
-1003
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1009
+    }
-1010
+}
-1011
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-1013
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1022
+}

↧ Expand context

-1023
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1036
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("ebs::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use ec2_query::config::IdentityCache;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use ec2_query::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = ec2_query::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-492
+    }
-493
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use ec2_query::config::IdentityCache;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use ec2_query::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-538
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use ec2_query::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -850,850 +945,945 @@

↥ Expand context

-850
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use ec2_query::config::BehaviorVersion;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use ec2_query::config::BehaviorVersion;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-884
+    }
-885
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use ec2_query::config::BehaviorVersion;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use ec2_query::config::BehaviorVersion;
     ///
     /// let config = ec2_query::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = ec2_query::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-919
+    }
-920
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-927
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-932
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-937
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_idempotency_token_provider(Some("00000000-0000-4000-8000-000000000000".into()));
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));

@@ -982,982 +1042,1042 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("AwsEc2");
             cfg.store_put(crate::idempotency_token::default_provider());
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-992
+    }
-993
+}
-994
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-998
+    }
-999
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-1002
+    }
-1003
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1009
+    }
-1010
+}
-1011
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-1013
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1022
+}

↧ Expand context

-1023
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1036
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("ec2_query::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/endpoint-rules/rust-client-codegen/src/config.rs

@@ -207,207 +301,302 @@

↥ Expand context

         self
-208
+    }
     /// Set the endpoint URL to use when making requests.
     ///
     /// Note: setting an endpoint URL will replace any endpoint resolver that has been set.
     ///
     /// # Panics
     /// Panics if an invalid URL is given.
     pub fn endpoint_url(mut self, endpoint_url: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.set_endpoint_url(::std::option::Option::Some(endpoint_url.into()));
         self
-218
+    }
-219
     /// Set the endpoint URL to use when making requests.
     ///
     /// Note: setting an endpoint URL will replace any endpoint resolver that has been set.
     ///
     /// # Panics
     /// Panics if an invalid URL is given.
     pub fn set_endpoint_url(&mut self, endpoint_url: ::std::option::Option<::std::string::String>) -> &mut Self {

         #[allow(deprecated)]
         self.set_endpoint_resolver(endpoint_url.map(|url| {
             ::aws_smithy_runtime_api::shared::IntoShared::into_shared(
                 ::aws_smithy_runtime::client::orchestrator::endpoints::StaticUriEndpointResolver::uri(url),
-231
+            )
         }));
         self
-234
+    }
     /// Sets the endpoint resolver to use when making requests.
     ///
--
     ///
     /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
     /// rules for `endpoint_rules`.
--
     ///
     ///
     /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
     /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
     /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
     ///
     /// # Examples
     /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
     /// ```no_run
     /// use endpoint_rules::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
     /// #[derive(Debug)]
     /// struct StageResolver { stage: String }
     /// impl ResolveEndpoint for StageResolver {
     ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
     ///         let stage = &self.stage;
     ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
     ///     }
     /// }
     /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
     /// let config = endpoint_rules::Config::builder().endpoint_resolver(resolver).build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
     pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
         self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
         self
-265
+    }
-266
     /// Sets the endpoint resolver to use when making requests.
     ///
--
     ///
     /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
     /// rules for `endpoint_rules`.
     ///
     pub fn set_endpoint_resolver(
         &mut self,
         endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
     ) -> &mut Self {
         self.runtime_components.set_endpoint_resolver(endpoint_resolver);
         self
-279
+    }
     /// Set the retry_config for the builder
     ///
     /// # Examples

↧ Expand context

     /// ```no_run
     /// use endpoint_rules::config::Config;
     /// use endpoint_rules::config::retry::RetryConfig;
     ///
     /// let retry_config = RetryConfig::standard().with_max_attempts(5);
     /// let config = Config::builder().retry_config(retry_config).build();
     /// ```
     pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
         self.set_retry_config(Some(retry_config));
         self
-293
+    }
-294
     /// Set the retry_config for the builder
     ///
     /// # Examples
     /// ```no_run
     /// use endpoint_rules::config::{Builder, Config};
     /// use endpoint_rules::config::retry::RetryConfig;
     ///
     /// fn disable_retries(builder: &mut Builder) {

@@ -447,448 +553,554 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use endpoint_rules::config::IdentityCache;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use endpoint_rules::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = endpoint_rules::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-482
+    }
-483
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use endpoint_rules::config::IdentityCache;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use endpoint_rules::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-528
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use endpoint_rules::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -839,840 +934,935 @@

↥ Expand context

-840
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use endpoint_rules::config::BehaviorVersion;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use endpoint_rules::config::BehaviorVersion;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-874
+    }
-875
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use endpoint_rules::config::BehaviorVersion;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use endpoint_rules::config::BehaviorVersion;
     ///
     /// let config = endpoint_rules::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = endpoint_rules::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-909
+    }
-910
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-917
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-922
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-927
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -975,976 +1035,1036 @@

↥ Expand context

         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.set_endpoint_resolver(Some({
             use crate::config::endpoint::ResolveEndpoint;
             crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
         }));
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-986
+    }
-987
+}
-988
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-992
+    }
-993
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-996
+    }
-997
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-1003
+    }
-1004
+}
-1005
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-1007
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1016
+}

↧ Expand context

-1017
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1030
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("endpoint_rules::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use json_rpc10::config::IdentityCache;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use json_rpc10::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = json_rpc10::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use json_rpc10::config::IdentityCache;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use json_rpc10::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use json_rpc10::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use json_rpc10::config::BehaviorVersion;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use json_rpc10::config::BehaviorVersion;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use json_rpc10::config::BehaviorVersion;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use json_rpc10::config::BehaviorVersion;
     ///
     /// let config = json_rpc10::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = json_rpc10::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -964,964 +1024,1024 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("JsonRpc10");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-974
+    }
-975
+}
-976
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-980
+    }
-981
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-984
+    }
-985
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-991
+    }
-992
+}
-993
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-995
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1004
+}

↧ Expand context

-1005
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1018
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("json_rpc10::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use json_rpc11::config::IdentityCache;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use json_rpc11::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = json_rpc11::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use json_rpc11::config::IdentityCache;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use json_rpc11::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use json_rpc11::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use json_rpc11::config::BehaviorVersion;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use json_rpc11::config::BehaviorVersion;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use json_rpc11::config::BehaviorVersion;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use json_rpc11::config::BehaviorVersion;
     ///
     /// let config = json_rpc11::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = json_rpc11::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -964,964 +1024,1024 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("JsonProtocol");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-974
+    }
-975
+}
-976
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-980
+    }
-981
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-984
+    }
-985
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-991
+    }
-992
+}
-993
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-995
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1004
+}

↧ Expand context

-1005
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1018
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("json_rpc11::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/misc/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use misc::config::IdentityCache;
     ///
     /// let config = misc::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use misc::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = misc::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use misc::config::IdentityCache;
     ///
     /// let config = misc::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use misc::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = misc::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use misc::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use misc::config::BehaviorVersion;
     ///
     /// let config = misc::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use misc::config::BehaviorVersion;
     ///
     /// let config = misc::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use misc::config::BehaviorVersion;
     ///
     /// let config = misc::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use misc::config::BehaviorVersion;
     ///
     /// let config = misc::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = misc::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -964,964 +1024,1024 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("MiscService");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-974
+    }
-975
+}
-976
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-980
+    }
-981
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-984
+    }
-985
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-991
+    }
-992
+}
-993
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-995
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1004
+}

↧ Expand context

-1005
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1018
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("misc::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/naming_test_casing/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_casing::config::IdentityCache;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_casing::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_casing::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_casing::config::IdentityCache;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_casing::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use naming_test_casing::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_casing::config::BehaviorVersion;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_casing::config::BehaviorVersion;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_casing::config::BehaviorVersion;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_casing::config::BehaviorVersion;
     ///
     /// let config = naming_test_casing::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_casing::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -966,966 +1026,1026 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("ACRONYMInside_Service");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-976
+    }
-977
+}
-978
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-982
+    }
-983
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-986
+    }
-987
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-993
+    }
-994
+}
-995
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-997
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1006
+}

↧ Expand context

-1007
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1020
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("naming_test_casing::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_ops::config::IdentityCache;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_ops::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_ops::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_ops::config::IdentityCache;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_ops::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use naming_test_ops::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_ops::config::BehaviorVersion;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_ops::config::BehaviorVersion;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_ops::config::BehaviorVersion;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_ops::config::BehaviorVersion;
     ///
     /// let config = naming_test_ops::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_ops::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -966,966 +1026,1026 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Config");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-976
+    }
-977
+}
-978
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-982
+    }
-983
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-986
+    }
-987
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-993
+    }
-994
+}
-995
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-997
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1006
+}

↧ Expand context

-1007
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1020
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("naming_test_ops::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/naming_test_structs/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_structs::config::IdentityCache;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_structs::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_structs::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use naming_test_structs::config::IdentityCache;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_structs::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use naming_test_structs::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -966,966 +1026,1026 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("NamingObstacleCourseStructs");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-976
+    }
-977
+}
-978
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-982
+    }
-983
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-986
+    }
-987
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-993
+    }
-994
+}
-995
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-997
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1006
+}

↧ Expand context

-1007
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1020
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("naming_test_structs::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/pokemon-service-awsjson-client/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::IdentityCache;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::IdentityCache;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use pokemon_service_awsjson_client::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use pokemon_service_awsjson_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_awsjson_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -966,966 +1026,1026 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("PokemonService");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-976
+    }
-977
+}
-978
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-982
+    }
-983
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-986
+    }
-987
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-993
+    }
-994
+}
-995
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-997
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1006
+}

↧ Expand context

-1007
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1020
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("pokemon_service_awsjson_client::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

tmp-codegen-diff/codegen-client-test/pokemon-service-client/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@

↥ Expand context

     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use pokemon_service_client::config::IdentityCache;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use pokemon_service_client::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = pokemon_service_client::Config::builder()

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
         self.set_identity_cache(identity_cache);
         self
-476
+    }
-477
     /// Set the identity cache for auth.
     ///
     /// The identity cache defaults to a lazy caching implementation that will resolve
     /// an identity when it is requested, and place it in the cache thereafter. Subsequent
     /// requests will take the value from the cache while it is still valid. Once it expires,
     /// the next request will result in refreshing the identity.
     ///
     /// This configuration allows you to disable or change the default caching mechanism.
     /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
     /// trait and pass that implementation into this function.
     ///
     /// # Examples
     ///
     /// Disabling identity caching:
     /// ```no_run
     /// use pokemon_service_client::config::IdentityCache;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use pokemon_service_client::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
         self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
         self
-522
+    }
     /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
     ///
     /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
     /// The SDK provides a default set of interceptors. An interceptor configured by this method
     /// will run after those default interceptors.
     ///

↧ Expand context

     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use pokemon_service_client::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(

@@ -834,834 +929,929 @@

↥ Expand context

-834
+    }
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use pokemon_service_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use pokemon_service_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
         self.set_behavior_version(Some(behavior_version));
         self
-868
+    }
-869
     /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
     ///
     /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
     /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
     /// all operations might be the ideal behavior but could break existing applications.
     ///
     /// # Examples
     ///
     /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
     /// ```no_run
     /// use pokemon_service_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use pokemon_service_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
--
     ///
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;
         self
-903
+    }
-904
     /// Convenience method to set the latest behavior major version
     ///
     /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
     pub fn behavior_version_latest(mut self) -> Self {
         self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));

↧ Expand context

         self
-911
+    }
     /// Adds a runtime plugin to the config.
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-916
+    }
     /// Adds a runtime plugin to the config.
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-921
+    }
     #[cfg(any(feature = "test-util", test))]
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
             ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)),
         )));
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());

@@ -966,966 +1026,1026 @@

↥ Expand context

         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("PokemonService");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-976
+    }
-977
+}
-978
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         self.config.clone()
-982
+    }
-983
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-986
+    }
-987
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         ::std::borrow::Cow::Borrowed(&self.runtime_components)
-993
+    }
-994
+}
-995
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-997
 /// A plugin that enables configuration for a single operation invocation
 ///
 /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 /// In the case of default values requested, they will be obtained from `client_config`.
 #[derive(Debug)]
 pub(crate) struct ConfigOverrideRuntimePlugin {
     pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
     pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1006
+}

↧ Expand context

-1007
 impl ConfigOverrideRuntimePlugin {
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(
         config_override: Builder,
         initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
         initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> Self {
         let mut layer = config_override.config;
         let mut components = config_override.runtime_components;
         #[allow(unused_mut)]
         let mut resolver =
             ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
-1020
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("pokemon_service_client::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

Client Test

Files changed: