Client Test

rev. 6f149fabf4cddbe8dcdce51f882ec9bdc2ae0647 (ignoring whitespace)

Files changed:

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

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

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::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 rest_json_extras::config::IdentityCache;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rest_json_extras::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::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 rest_json_extras::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 rest_json_extras::config::BehaviorVersion;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_json_extras::config::BehaviorVersion;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::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 rest_json_extras::config::BehaviorVersion;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_json_extras::config::BehaviorVersion;
     ///
     /// let config = rest_json_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_json_extras::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("RestJsonExtras");
             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("rest_json_extras::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml::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 rest_xml::config::IdentityCache;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rest_xml::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rest_xml::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml::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 rest_xml::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 rest_xml::config::BehaviorVersion;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml::config::BehaviorVersion;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml::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 rest_xml::config::BehaviorVersion;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml::config::BehaviorVersion;
     ///
     /// let config = rest_xml::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml::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("RestXml");
             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("rest_xml::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::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 rest_xml_extras::config::IdentityCache;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rest_xml_extras::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::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 rest_xml_extras::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 rest_xml_extras::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_extras::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::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 rest_xml_extras::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_extras::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras::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("RestXmlExtras");
             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("rest_xml_extras::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::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 rest_xml_extras_unwrapped::config::IdentityCache;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rest_xml_extras_unwrapped::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::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 rest_xml_extras_unwrapped::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 rest_xml_extras_unwrapped::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_extras_unwrapped::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::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 rest_xml_extras_unwrapped::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_extras_unwrapped::config::BehaviorVersion;
     ///
     /// let config = rest_xml_extras_unwrapped::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_extras_unwrapped::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("RestXmlExtrasUnwrappedErrors");
             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("rest_xml_extras_unwrapped::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::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 rest_xml_namespace::config::IdentityCache;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rest_xml_namespace::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::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 rest_xml_namespace::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 rest_xml_namespace::config::BehaviorVersion;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_namespace::config::BehaviorVersion;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::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 rest_xml_namespace::config::BehaviorVersion;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rest_xml_namespace::config::BehaviorVersion;
     ///
     /// let config = rest_xml_namespace::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rest_xml_namespace::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("RestXmlWithNamespace");
             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("rest_xml_namespace::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::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 rpcv2cbor::config::IdentityCache;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rpcv2cbor::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::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 rpcv2cbor::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 rpcv2cbor::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rpcv2cbor::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::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 rpcv2cbor::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rpcv2cbor::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor::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());

@@ -965,965 +1025,1025 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RpcV2Protocol");
             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(crate::sdk_feature_tracker::rpc_v2_cbor::RpcV2CborFeatureTrackerInterceptor::new());
         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 }
-975
+    }
-976
+}
-977
 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()
-981
+    }
-982
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-985
+    }
-986
     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)
-992
+    }
-993
+}
-994
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-996
 /// 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,
-1005
+}

↧ Expand context

-1006
 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);
-1019
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("rpcv2cbor::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::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 rpcv2cbor_extras::config::IdentityCache;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use rpcv2cbor_extras::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::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 rpcv2cbor_extras::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 rpcv2cbor_extras::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use rpcv2cbor_extras::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::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 rpcv2cbor_extras::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use rpcv2cbor_extras::config::BehaviorVersion;
     ///
     /// let config = rpcv2cbor_extras::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = rpcv2cbor_extras::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());

@@ -967,967 +1027,1027 @@

↥ Expand context

             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RpcV2CborService");
             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(crate::sdk_feature_tracker::rpc_v2_cbor::RpcV2CborFeatureTrackerInterceptor::new());
         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 }
-977
+    }
-978
+}
-979
 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()
-983
+    }
-984
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults

-987
+    }
-988
     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)
-994
+    }
-995
+}
-996
 /// Cross-operation shared-state singletons
 // Cross-operation shared-state singletons
-998
 /// 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,
-1007
+}

↧ Expand context

-1008
 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);
-1021
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("rpcv2cbor_extras::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

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

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

↥ Expand context

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

     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = simple::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 simple::config::IdentityCache;
     ///
     /// let config = simple::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = simple::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use simple::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = simple::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()
     ///     )
     ///     // ...
     ///     .build();
     /// let client = simple::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 simple::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 simple::config::BehaviorVersion;
     ///
     /// let config = simple::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = simple::Client::from_conf(config);
     /// ```
     ///

     /// Customizing behavior major version:
     /// ```no_run
     /// use simple::config::BehaviorVersion;
     ///
     /// let config = simple::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = simple::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 simple::config::BehaviorVersion;
     ///
     /// let config = simple::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = simple::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use simple::config::BehaviorVersion;
     ///
     /// let config = simple::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = simple::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("SimpleService");
             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("simple::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,

Pages: 1 2