Client Test

rev. dfb5149b65b7bcc09edd15b8e071ad43b5ac5943 (ignoring whitespace)

Files changed:

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

@@ -1,1 +32,33 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /* CustomizableOperationGenerator.kt:72 */
 /// `CustomizableOperation` allows for configuring a single operation invocation before it is sent.
 pub struct CustomizableOperation<T, E, B> {
     customizable_send: B,
     config_override: ::std::option::Option<crate::config::Builder>,
     interceptors: Vec<::aws_smithy_runtime_api::client::interceptors::SharedInterceptor>,
     runtime_plugins: Vec<::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin>,
     _output: ::std::marker::PhantomData<T>,
     _error: ::std::marker::PhantomData<E>,
-12
+}
-13

↧ Expand context

 impl<T, E, B> CustomizableOperation<T, E, B> {
     /// Creates a new `CustomizableOperation` from `customizable_send`.
     #[allow(dead_code)] // unused when a service does not provide any operations
     pub(crate) fn new(customizable_send: B) -> Self {
         Self {
             customizable_send,
             config_override: ::std::option::Option::None,
             interceptors: vec![],
             runtime_plugins: vec![],
             _output: ::std::marker::PhantomData,
             _error: ::std::marker::PhantomData,
-25
+        }
-26
+    }
-27
     pub(crate) fn execute<U>(self, f: impl ::std::ops::FnOnce(B, crate::config::Builder) -> U) -> U {
         let mut config_override = self.config_override.unwrap_or_default();
         self.interceptors.into_iter().for_each(|interceptor| {
             config_override.push_interceptor(interceptor);
         });
         self.runtime_plugins.into_iter().for_each(|plugin| {

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

@@ -1,1 +12,13 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* CustomizableOperationGenerator.kt:204 */
 pub type BoxFuture<T> = ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = T> + ::std::marker::Send>>;
-4
 pub type SendResult<T, E> =
     ::std::result::Result<T, ::aws_smithy_runtime_api::client::result::SdkError<E, ::aws_smithy_runtime_api::client::orchestrator::HttpResponse>>;
-7
 pub trait CustomizableSend<T, E>: ::std::marker::Send + ::std::marker::Sync {
     // Takes an owned `self` as the implementation will internally call methods that take `self`.
     // If it took `&self`, that would make this trait object safe, but some implementing types do not
     // derive `Clone`, unable to yield `self` from `&self`.
     fn send(self, config_override: crate::config::Builder) -> BoxFuture<SendResult<T, E>>;

↧ Expand context

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

@@ -1,1 +21,25 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* FluentClientGenerator.kt:187 */
 impl super::Client {
     /* FluentClientGenerator.kt:221 */
     /// Constructs a fluent builder for the [`Structs`](crate::operation::structs::builders::StructsFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`result(Result)`](crate::operation::structs::builders::StructsFluentBuilder::result) / [`set_result(Option<Result>)`](crate::operation::structs::builders::StructsFluentBuilder::set_result):<br>required: **false**<br>(undocumented)<br>
     ///   - [`result_list(Result)`](crate::operation::structs::builders::StructsFluentBuilder::result_list) / [`set_result_list(Option<Vec::<Result>>)`](crate::operation::structs::builders::StructsFluentBuilder::set_result_list):<br>required: **false**<br>(undocumented)<br>
     ///   - [`option(Option)`](crate::operation::structs::builders::StructsFluentBuilder::option) / [`set_option(Option<Option>)`](crate::operation::structs::builders::StructsFluentBuilder::set_option):<br>required: **false**<br>(undocumented)<br>
     ///   - [`option_list(Result)`](crate::operation::structs::builders::StructsFluentBuilder::option_list) / [`set_option_list(Option<Vec::<Result>>)`](crate::operation::structs::builders::StructsFluentBuilder::set_option_list):<br>required: **false**<br>(undocumented)<br>
     ///   - [`something_else(SomethingElse)`](crate::operation::structs::builders::StructsFluentBuilder::something_else) / [`set_something_else(Option<SomethingElse>)`](crate::operation::structs::builders::StructsFluentBuilder::set_something_else):<br>required: **false**<br>(undocumented)<br>
     /// - On success, responds with [`StructsOutput`](crate::operation::structs::StructsOutput) with field(s):
     ///   - [`result(Option<Result>)`](crate::operation::structs::StructsOutput::result): (undocumented)
     ///   - [`result_list(Option<Vec::<Result>>)`](crate::operation::structs::StructsOutput::result_list): (undocumented)
     ///   - [`option(Option<Option>)`](crate::operation::structs::StructsOutput::option): (undocumented)
     ///   - [`option_list(Option<Vec::<Result>>)`](crate::operation::structs::StructsOutput::option_list): (undocumented)
     ///   - [`something_else(Option<SomethingElse>)`](crate::operation::structs::StructsOutput::something_else): (undocumented)
     /// - On failure, responds with [`SdkError<StructsError>`](crate::operation::structs::StructsError)
     /* FluentClientGenerator.kt:234 */
     pub fn structs(&self) -> crate::operation::structs::builders::StructsFluentBuilder {
         crate::operation::structs::builders::StructsFluentBuilder::new(self.handle.clone())
-23
+    }
     /* FluentClientGenerator.kt:187 */
-25
+}

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

@@ -1,1 +171,209 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// Configuration for a naming_test_structs service client.
 /* ServiceConfigGenerator.kt:409 */
 /// /* ServiceConfigGenerator.kt:409 */Configuration for a naming_test_structs service client.
 ///
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::fmt::Debug)]
 /* ServiceConfigGenerator.kt:414 */
 pub struct Config {
     // Both `config` and `cloneable` are the same config, but the cloneable one
     /* ServiceConfigGenerator.kt:415 */// Both `config` and `cloneable` are the same config, but the cloneable one
     // is kept around so that it is possible to convert back into a builder. This can be
     // optimized in the future.
     pub(crate) config: crate::config::FrozenLayer,
     cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
     /* ServiceConfigGenerator.kt:414 */
-18
+}
 /* ServiceConfigGenerator.kt:433 */
 impl Config {
     ///
     /// /* ServiceConfigGenerator.kt:434 */
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     /* ServiceConfigGenerator.kt:435 */
     pub fn builder() -> Builder {
         Builder::default()
-31
+    }
     /* ServiceConfigGenerator.kt:440 */
     /// Converts this config back into a builder so that it can be tweaked.
     pub fn to_builder(&self) -> Builder {
         Builder {
             config: self.cloneable.clone(),
             runtime_components: self.runtime_components.clone(),
             runtime_plugins: self.runtime_plugins.clone(),
             behavior_version: self.behavior_version,
-40
+        }
-41
+    }
     /* StalledStreamProtectionConfigCustomization.kt:57 */
     /// Return a reference to the stalled stream protection configuration contained in this config, if any.
     pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
         self.config.load::<crate::config::StalledStreamProtectionConfig>()
-46
+    }
     /* HttpConnectorConfigDecorator.kt:52 */
     /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
     pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
         self.runtime_components.http_client()
-51
+    }
     /* EndpointConfigCustomization.kt:47 */
     /// Returns the endpoint resolver.
     pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
         self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
-56
+    }
     /* ResiliencyConfigCustomization.kt:51 */
     /// Return a reference to the retry configuration contained in this config, if any.
     pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
         self.config.load::<::aws_smithy_types::retry::RetryConfig>()
-61
+    }
-62
     /// Return a cloned shared async sleep implementation from this config, if any.
     pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
         self.runtime_components.sleep_impl()
-66
+    }
-67
     /// Return a reference to the timeout configuration contained in this config, if any.
     pub fn timeout_config(&self) -> ::std::option::Option<&::aws_smithy_types::timeout::TimeoutConfig> {
         self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>()
-71
+    }
-72
     /// Returns a reference to the retry partition contained in this config, if any.
     ///
     /// WARNING: This method is unstable and may be removed at any time. Do not rely on this
     /// method for anything!
     pub fn retry_partition(&self) -> ::std::option::Option<&::aws_smithy_runtime::client::retries::RetryPartition> {
         self.config.load::<::aws_smithy_runtime::client::retries::RetryPartition>()
-79
+    }
     /* IdentityCacheDecorator.kt:96 */
     /// Returns the configured identity cache for auth.
     pub fn identity_cache(&self) -> ::std::option::Option<crate::config::SharedIdentityCache> {
         self.runtime_components.identity_cache()
-84
+    }
     /* InterceptorConfigCustomization.kt:30 */
     /// Returns interceptors currently registered by the user.
     pub fn interceptors(&self) -> impl Iterator<Item = crate::config::SharedInterceptor> + '_ {
         self.runtime_components.interceptors()
-89
+    }
     /* TimeSourceCustomization.kt:34 */
     /// Return time source used for this service.
     /* TimeSourceCustomization.kt:35 */
     pub fn time_source(&self) -> ::std::option::Option<::aws_smithy_async::time::SharedTimeSource> {
         /* TimeSourceCustomization.kt:39 */
         self.runtime_components.time_source()
         /* TimeSourceCustomization.kt:35 */
-97
+    }
     /* RetryClassifierConfigCustomization.kt:39 */
     /// Returns retry classifiers currently registered by the user.
     pub fn retry_classifiers(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier> + '_ {
         self.runtime_components.retry_classifiers()
-102
+    }
     /* ServiceConfigGenerator.kt:433 */
-104
+}
 /// Builder for creating a `Config`.
 /// /* ServiceConfigGenerator.kt:458 */Builder for creating a `Config`.
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::fmt::Debug)]
 /* ServiceConfigGenerator.kt:460 */
 pub struct Builder {
     pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
     /* ServiceConfigGenerator.kt:461 */ pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
     pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
     pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
     pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
     /* ServiceConfigGenerator.kt:460 */
-115
+}
 /* ServiceConfigGenerator.kt:476 */
 impl ::std::default::Default for Builder {
     /* ServiceConfigGenerator.kt:477 */
     fn default() -> Self {
         Self {
             config: ::std::default::Default::default(),
             runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
             runtime_plugins: ::std::default::Default::default(),
             behavior_version: ::std::default::Default::default(),
-125
+        }
-126
+    }
     /* ServiceConfigGenerator.kt:476 */
-128
+}
 /* ServiceConfigGenerator.kt:492 */
 impl Builder {
     ///
     /// /* ServiceConfigGenerator.kt:493 */
     /// Constructs a config builder.
     /// <div class="warning">
     /// Note that a config created from this builder will not have the same safe defaults as one created by
     /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
     /// </div>
     ///
     /* ServiceConfigGenerator.kt:494 */
     pub fn new() -> Self {
         Self::default()
-141
+    }
     /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// but not those in runtime components.
     /// /* ServiceConfigGenerator.kt:327 */Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
     /// /* ServiceConfigGenerator.kt:328 */but not those in runtime components.
     /* RustType.kt:516 */
     #[allow(unused)]
     /* ServiceConfigGenerator.kt:330 */
     pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
         /* ServiceConfigGenerator.kt:334 */
         let mut builder = Self::new();
         /* StalledStreamProtectionConfigCustomization.kt:102 */
         builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
         /* ResiliencyConfigCustomization.kt:294 */
         builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
         /* ResiliencyConfigCustomization.kt:298 */
         builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
         /* ResiliencyConfigCustomization.kt:302 */
         builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
         /* ServiceConfigGenerator.kt:338 */
         builder
         /* ServiceConfigGenerator.kt:330 */
-161
+    }
     /* StalledStreamProtectionConfigCustomization.kt:69 */
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn stalled_stream_protection(mut self, stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig) -> Self {
         self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
         self
-168
+    }
     /* StalledStreamProtectionConfigCustomization.kt:84 */
     /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
     /// to configure protection for stalled streams.
     pub fn set_stalled_stream_protection(
         &mut self,
         stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>,
     ) -> &mut Self {
         self.config.store_or_unset(stalled_stream_protection_config);
         self
-178
+    }
     /* HttpConnectorConfigDecorator.kt:65 */
     /// Sets the HTTP client to use when making requests.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use naming_test_structs::config::Config;

↧ Expand context

     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///     .with_webpki_roots()
     ///     .https_only()
     ///     .enable_http1()
     ///     .enable_http2()
     ///     .build();
     /// let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///
     /// // This connector can then be given to a generated service Config
     /// let config = my_service_client::Config::builder()
     ///     .endpoint_url("https://example.com")
     ///     .http_client(hyper_client)
     ///     .build();
     /// let client = my_service_client::Client::from_conf(config);
     /// # }
     /// # }
     /// ```
     pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {

@@ -179,217 +461,511 @@

↥ Expand context

     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]
     /// # fn example() {
     /// use std::time::Duration;
     /// use naming_test_structs::config::{Builder, Config};
     /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
     ///
     /// fn override_http_client(builder: &mut Builder) {
     ///     let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
     ///         .with_webpki_roots()
     ///         .https_only()
     ///         .enable_http1()
     ///         .enable_http2()
     ///         .build();
     ///     let hyper_client = HyperClientBuilder::new().build(https_connector);
     ///     builder.set_http_client(Some(hyper_client));
     /// }
     ///

     /// let mut builder = naming_test_structs::Config::builder();
     /// override_http_client(&mut builder);
     /// let config = builder.build();
     /// # }
     /// # }
     /// ```
     pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
         self.runtime_components.set_http_client(http_client);
         self
-246
+    }
     /* EndpointConfigCustomization.kt:73 */
     /// Set the endpoint URL to use when making requests.
     ///
     /// Note: setting an endpoint URL will replace any endpoint resolver that has been set.
     ///
     /// # Panics
     /// Panics if an invalid URL is given.
     pub fn endpoint_url(mut self, endpoint_url: impl ::std::convert::Into<::std::string::String>) -> Self {
         self.set_endpoint_url(::std::option::Option::Some(endpoint_url.into()));
         self
-257
+    }
-258
     /// Set the endpoint URL to use when making requests.
     ///
     /// Note: setting an endpoint URL will replace any endpoint resolver that has been set.
     ///
     /// # Panics
     /// Panics if an invalid URL is given.
     pub fn set_endpoint_url(&mut self, endpoint_url: ::std::option::Option<::std::string::String>) -> &mut Self {
         #[allow(deprecated)]
         self.set_endpoint_resolver(endpoint_url.map(|url| {
             ::aws_smithy_runtime_api::shared::IntoShared::into_shared(
                 ::aws_smithy_runtime::client::orchestrator::endpoints::StaticUriEndpointResolver::uri(url),
-270
+            )
         }));
         self
-273
+    }
     /* EndpointConfigCustomization.kt:105 */
     /// Sets the endpoint resolver to use when making requests.
     ///
     /// This service does not define a default endpoint resolver.
     ///
     /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
     /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
     /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
     ///
     /// # Examples
     /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
     /// ```no_run
     /// use naming_test_structs::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
     /// #[derive(Debug)]
     /// struct StageResolver { stage: String }
     /// impl ResolveEndpoint for StageResolver {
     ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
     ///         let stage = &self.stage;
     ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
     ///     }
     /// }
     /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
     /// let config = naming_test_structs::Config::builder().endpoint_resolver(resolver).build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
         self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
         self
-302
+    }
-303
     /// Sets the endpoint resolver to use when making requests.
     ///
     /// This service does not define a default endpoint resolver.
     /* EndpointConfigCustomization.kt:143 */
     pub fn set_endpoint_resolver(
         &mut self,
         endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
     ) -> &mut Self {
         self.runtime_components.set_endpoint_resolver(endpoint_resolver);
         self
-314
+    }
     /* ResiliencyConfigCustomization.kt:81 */
     /// Set the retry_config for the builder
     ///
     /// # Examples
     /// ```no_run
     /// use naming_test_structs::config::Config;
     /// use naming_test_structs::config::retry::RetryConfig;
     ///
     /// let retry_config = RetryConfig::standard().with_max_attempts(5);
     /// let config = Config::builder().retry_config(retry_config).build();
     /// ```
     pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
         self.set_retry_config(Some(retry_config));
         self
-329
+    }
-330
     /// Set the retry_config for the builder
     ///
     /// # Examples
     /// ```no_run
     /// use naming_test_structs::config::{Builder, Config};
     /// use naming_test_structs::config::retry::RetryConfig;
     ///
     /// fn disable_retries(builder: &mut Builder) {
     ///     let retry_config = RetryConfig::standard().with_max_attempts(1);
     ///     builder.set_retry_config(Some(retry_config));
     /// }
     ///
     /// let mut builder = Config::builder();
     /// disable_retries(&mut builder);
     /// let config = builder.build();
     /// ```
     /* ResiliencyConfigCustomization.kt:118 */
     pub fn set_retry_config(&mut self, retry_config: ::std::option::Option<::aws_smithy_types::retry::RetryConfig>) -> &mut Self {
         retry_config.map(|r| self.config.store_put(r));
         self
-351
+    }
     /* ResiliencyConfigCustomization.kt:128 */
     /// Set the sleep_impl for the builder
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use naming_test_structs::config::{AsyncSleep, Config, SharedAsyncSleep, Sleep};
     ///
     /// #[derive(Debug)]
     /// pub struct ForeverSleep;
     ///
     /// impl AsyncSleep for ForeverSleep {
     ///     fn sleep(&self, duration: std::time::Duration) -> Sleep {
     ///         Sleep::new(std::future::pending())
     ///     }
     /// }
     ///
     /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
     /// let config = Config::builder().sleep_impl(sleep_impl).build();
     /// ```
     pub fn sleep_impl(mut self, sleep_impl: impl crate::config::AsyncSleep + 'static) -> Self {
         self.set_sleep_impl(Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(sleep_impl)));
         self
-375
+    }
-376
     /// Set the sleep_impl for the builder
     ///
     /// # Examples
     ///
     /// ```no_run
     /// use naming_test_structs::config::{AsyncSleep, Builder, Config, SharedAsyncSleep, Sleep};
     ///
     /// #[derive(Debug)]
     /// pub struct ForeverSleep;
     ///
     /// impl AsyncSleep for ForeverSleep {
     ///     fn sleep(&self, duration: std::time::Duration) -> Sleep {
     ///         Sleep::new(std::future::pending())
     ///     }
     /// }
     ///
     /// fn set_never_ending_sleep_impl(builder: &mut Builder) {
     ///     let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
     ///     builder.set_sleep_impl(Some(sleep_impl));
     /// }
     ///
     /// let mut builder = Config::builder();
     /// set_never_ending_sleep_impl(&mut builder);
     /// let config = builder.build();
     /// ```
     /* ResiliencyConfigCustomization.kt:184 */
     pub fn set_sleep_impl(&mut self, sleep_impl: ::std::option::Option<crate::config::SharedAsyncSleep>) -> &mut Self {
         self.runtime_components.set_sleep_impl(sleep_impl);
         self
-406
+    }
     /* ResiliencyConfigCustomization.kt:194 */
     /// Set the timeout_config for the builder
     ///
     /// # Examples
     ///
     /// ```no_run
     /// # use std::time::Duration;
     /// use naming_test_structs::config::Config;
     /// use naming_test_structs::config::timeout::TimeoutConfig;
     ///
     /// let timeout_config = TimeoutConfig::builder()
     ///     .operation_attempt_timeout(Duration::from_secs(1))
     ///     .build();
     /// let config = Config::builder().timeout_config(timeout_config).build();
     /// ```
     pub fn timeout_config(mut self, timeout_config: ::aws_smithy_types::timeout::TimeoutConfig) -> Self {
         self.set_timeout_config(Some(timeout_config));
         self
-425
+    }
-426
     /// Set the timeout_config for the builder.
     ///
     /// Setting this to `None` has no effect if another source of configuration has set timeouts. If you
     /// are attempting to disable timeouts, use [`TimeoutConfig::disabled`](::aws_smithy_types::timeout::TimeoutConfig::disabled)
     ///
     ///
     /// # Examples
     ///
     /// ```no_run
     /// # use std::time::Duration;
     /// use naming_test_structs::config::{Builder, Config};
     /// use naming_test_structs::config::timeout::TimeoutConfig;
     ///
     /// fn set_request_timeout(builder: &mut Builder) {
     ///     let timeout_config = TimeoutConfig::builder()
     ///         .operation_attempt_timeout(Duration::from_secs(1))
     ///         .build();
     ///     builder.set_timeout_config(Some(timeout_config));
     /// }
     ///
     /// let mut builder = Config::builder();
     /// set_request_timeout(&mut builder);
     /// let config = builder.build();
     /// ```
     /* ResiliencyConfigCustomization.kt:248 */
     pub fn set_timeout_config(&mut self, timeout_config: ::std::option::Option<::aws_smithy_types::timeout::TimeoutConfig>) -> &mut Self {
         // passing None has no impact.
         let Some(mut timeout_config) = timeout_config else { return self };
-455
         if let Some(base) = self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>() {
             timeout_config.take_defaults_from(base);
-458
+        }
         self.config.store_put(timeout_config);
         self
-461
+    }
     /* ResiliencyConfigCustomization.kt:266 */
     /// Set the partition for retry-related state. When clients share a retry partition, they will
     /// also share things like token buckets and client rate limiters. By default, all clients
     /// for the same service will share a partition.
     pub fn retry_partition(mut self, retry_partition: ::aws_smithy_runtime::client::retries::RetryPartition) -> Self {
         self.set_retry_partition(Some(retry_partition));
         self
-469
+    }
     /* ResiliencyConfigCustomization.kt:279 */
     /// Set the partition for retry-related state. When clients share a retry partition, they will
     /// also share things like token buckets and client rate limiters. By default, all clients
     /// for the same service will share a partition.
     pub fn set_retry_partition(
         &mut self,
         retry_partition: ::std::option::Option<::aws_smithy_runtime::client::retries::RetryPartition>,
     ) -> &mut Self {
         retry_partition.map(|r| self.config.store_put(r));
         self
-480
+    }
     /* IdentityCacheDecorator.kt:77 */
     /// 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.

↧ Expand context

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

@@ -493,543 +552,603 @@

↥ Expand context

     /// use naming_test_structs::config::IdentityCache;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use naming_test_structs::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .identity_cache(
     ///         IdentityCache::lazy()
     ///             // change the load timeout to 10 seconds
     ///             .load_timeout(Duration::from_secs(10))
     ///             .build()

     ///     )
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
-568
     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
-572
+    }
     /* InterceptorConfigCustomization.kt:41 */
     /// 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.
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {

↧ Expand context

     /// # #[test]
     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::phase::BeforeTransmit;
     /// use aws_smithy_runtime_api::client::interceptors::{Interceptor, InterceptorContext};
     /// use aws_smithy_types::config_bag::ConfigBag;
     /// use naming_test_structs::config::Config;
     ///
     /// fn base_url() -> String {
     ///     // ...
     ///     # String::new()
     /// }
     ///
     /// #[derive(Debug)]
     /// pub struct UriModifierInterceptor;
     /// impl Intercept for UriModifierInterceptor {
     ///     fn modify_before_signing(
     ///         &self,
     ///         context: &mut InterceptorContext<BeforeTransmit>,
     ///         _cfg: &mut ConfigBag,
     ///     ) -> Result<(), aws_smithy_runtime_api::client::interceptors::BoxError> {

@@ -599,650 +670,724 @@

↥ Expand context

     ///             &self,
     ///             context: &mut InterceptorContext<BeforeTransmit>,
     ///             _cfg: &mut ConfigBag,
     ///         ) -> Result<(), aws_smithy_runtime_api::client::interceptors::BoxError> {
     ///             let request = context.request_mut();
     ///             let uri = format!("{}{}", base_url(), request.uri().path());
     ///             *request.uri_mut() = uri.parse()?;
     ///
     ///             Ok(())
     ///         }
     ///     }
     ///     builder.push_interceptor(SharedInterceptor::new(UriModifierInterceptor));
     /// }
     ///
     /// let mut builder = Config::builder();
     /// modify_request_uri(&mut builder);
     /// let config = builder.build();
     /// # }
     /// # }
     /// ```

     pub fn push_interceptor(&mut self, interceptor: crate::config::SharedInterceptor) -> &mut Self {
         self.runtime_components.push_interceptor(interceptor);
         self
-673
+    }
-674
     /// Set [`SharedInterceptor`](crate::config::SharedInterceptor)s for the builder.
     pub fn set_interceptors(&mut self, interceptors: impl IntoIterator<Item = crate::config::SharedInterceptor>) -> &mut Self {
         self.runtime_components.set_interceptors(interceptors.into_iter());
         self
-679
+    }
     /* TimeSourceCustomization.kt:47 */
     /// Sets the time source used for this service
     pub fn time_source(mut self, time_source: impl ::aws_smithy_async::time::TimeSource + 'static) -> Self {
         self.set_time_source(::std::option::Option::Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(
             time_source,
         )));
         self
-687
+    }
     /* TimeSourceCustomization.kt:61 */
     /// Sets the time source used for this service
     pub fn set_time_source(&mut self, time_source: ::std::option::Option<::aws_smithy_async::time::SharedTimeSource>) -> &mut Self {
         self.runtime_components.set_time_source(time_source);
         self
-693
+    }
     /* RetryClassifierConfigCustomization.kt:50 */
     /// Add type implementing [`ClassifyRetry`](::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry) that will be used by the
     /// [`RetryStrategy`](::aws_smithy_runtime_api::client::retries::RetryStrategy) to determine what responses should be retried.
     ///
     /// A retry classifier configured by this method will run according to its [priority](::aws_smithy_runtime_api::client::retries::classifiers::RetryClassifierPriority).
     ///
     /// # Examples
     /// ```no_run
     /// # #[cfg(test)]
     /// # mod tests {
     /// # #[test]

↧ Expand context

     /// # fn example() {
     /// use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
     /// use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
     /// use aws_smithy_runtime_api::client::retries::classifiers::{
     ///     ClassifyRetry, RetryAction, RetryClassifierPriority,
     /// };
     /// use aws_smithy_types::error::metadata::ProvideErrorMetadata;
     /// use aws_smithy_types::retry::ErrorKind;
     /// use std::error::Error as StdError;
     /// use std::marker::PhantomData;
     /// use naming_test_structs::config::Config;
     /// # struct SomeOperationError {}
     ///
     /// const RETRYABLE_ERROR_CODES: &[&str] = [
     ///     // List error codes to be retried here...
     /// ];
     ///
     /// // When classifying at an operation's error type, classifiers require a generic parameter.
     /// // When classifying the HTTP response alone, no generic is needed.
     /// #[derive(Debug, Default)]

@@ -805,859 +864,919 @@

↥ Expand context

     ///
     ///         fn name(&self) -> &'static str { "Example Error Code Classifier" }
     ///     }
     ///
     ///     builder.push_retry_classifier(ExampleErrorCodeClassifier::<SomeOperationError>::new())
     /// }
     ///
     /// let mut builder = Config::builder();
     /// set_example_error_code_classifier(&mut builder);
     /// let config = builder.build();
     /// # }
     /// # }
     /// ```
     pub fn push_retry_classifier(
         &mut self,
         retry_classifier: ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier,
     ) -> &mut Self {
         self.runtime_components.push_retry_classifier(retry_classifier);
         self
-878
+    }

-879
     /// Set [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier)s for the builder, replacing any that
     /// were previously set.
     pub fn set_retry_classifiers(
         &mut self,
         retry_classifiers: impl IntoIterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier>,
     ) -> &mut Self {
         self.runtime_components.set_retry_classifiers(retry_classifiers.into_iter());
         self
-888
+    }
     /* ServiceConfigGenerator.kt:375 */
     /// 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

↧ Expand context

     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
-919

@@ -882,937 +1139,1238 @@

↥ Expand context

     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use naming_test_structs::config::BehaviorVersion;
     ///
     /// let config = naming_test_structs::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = naming_test_structs::Client::from_conf(config);
     /// ```
-954
     pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
         self.behavior_version = behavior_version;

         self
-958
+    }
-959
     /// 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()));
         self
-966
+    }
     /// Adds a runtime plugin to the config.
     /// /* ServiceConfigGenerator.kt:509 */Adds a runtime plugin to the config.
     /* ServiceConfigGenerator.kt:513 */
     pub fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
         self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
         self
-972
+    }
     /// Adds a runtime plugin to the config.
     /// /* ServiceConfigGenerator.kt:522 */Adds a runtime plugin to the config.
     /* ServiceConfigGenerator.kt:526 */
     pub fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
         self.runtime_plugins.push(plugin);
         self
-978
+    }
     /* RustType.kt:516 */
     #[cfg(any(feature = "test-util", test))]
     /* RustType.kt:516 */
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     /// /* ServiceConfigGenerator.kt:541 */Apply test defaults to the builder
     /* ServiceConfigGenerator.kt:542 */
     pub fn apply_test_defaults(&mut self) -> &mut Self {
         /* TimeSourceCustomization.kt:88 */
         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)),
         )));
         /* ServiceConfigGenerator.kt:544 */
         self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());
         /* ServiceConfigGenerator.kt:545 */
         self
         /* ServiceConfigGenerator.kt:542 */
-995
+    }
     /* RustType.kt:516 */
     #[cfg(any(feature = "test-util", test))]
     /* RustType.kt:516 */
     #[allow(unused_mut)]
     /// Apply test defaults to the builder
     /// /* ServiceConfigGenerator.kt:550 */Apply test defaults to the builder
     /* ServiceConfigGenerator.kt:551 */
     pub fn with_test_defaults(mut self) -> Self {
         /* ServiceConfigGenerator.kt:552 */
         self.apply_test_defaults();
         self
         /* ServiceConfigGenerator.kt:551 */
-1007
+    }
     /// Builds a [`Config`].
     /// /* ServiceConfigGenerator.kt:555 */Builds a [`Config`].
     /* ServiceConfigGenerator.kt:556 */
     #[allow(unused_mut)]
     /* ServiceConfigGenerator.kt:557 */
     pub fn build(mut self) -> Config {
         /* ServiceConfigGenerator.kt:558 */
         let mut layer = self.config;
         /* TimeSourceCustomization.kt:77 */
         if self.runtime_components.time_source().is_none() {
             self.runtime_components
                 .set_time_source(::std::option::Option::Some(::std::default::Default::default()));
-1019
+        }
         /* ServiceConfigGenerator.kt:567 */
         Config {
             /* ServiceConfigGenerator.kt:568 */
             config: crate::config::Layer::from(layer.clone())
                 .with_name("naming_test_structs::config::Config")
                 .freeze(),
             cloneable: layer,
             runtime_components: self.runtime_components,
             runtime_plugins: self.runtime_plugins,
             behavior_version: self.behavior_version,
             /* ServiceConfigGenerator.kt:567 */
-1031
+        }
         /* ServiceConfigGenerator.kt:557 */
-1033
+    }
     /* ServiceConfigGenerator.kt:492 */
-1035
+}
 /* ServiceRuntimePluginGenerator.kt:116 */
 #[derive(::std::fmt::Debug)]
 pub(crate) struct ServiceRuntimePlugin {
     config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
     runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
-1041
+}
-1042
 impl ServiceRuntimePlugin {
     pub fn new(_service_config: crate::config::Config) -> Self {
         let config = {
             let mut cfg = ::aws_smithy_types::config_bag::Layer::new("NamingObstacleCourseStructs");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-1055
+    }
-1056
+}
-1057
 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()
-1061
+    }
-1062
     fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
         ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
-1065
+    }
-1066
     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)
-1072
+    }
-1073
+}
-1074
 /// Cross-operation shared-state singletons
-1076
 /* ConfigOverrideRuntimePluginGenerator.kt:42 */
 /// 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,
-1086
+}
-1087
 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);
-1100
         let _ = resolver;
         Self {
             config: ::aws_smithy_types::config_bag::Layer::from(layer)
                 .with_name("naming_test_structs::config::ConfigOverrideRuntimePlugin")
                 .freeze(),
             components,
-1107
+        }
-1108
+    }
-1109
+}
-1110
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ConfigOverrideRuntimePlugin {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         Some(self.config.clone())
-1114
+    }
-1115
     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.components)
-1121
+    }
-1122
+}
-1123
 /* ClientRuntimeTypesReExportGenerator.kt:24 */
 pub use ::aws_smithy_runtime::client::identity::IdentityCache;
 pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
 pub use ::aws_smithy_types::config_bag::ConfigBag;
-1128
 /* ResiliencyConfigCustomization.kt:318 */
 pub use ::aws_smithy_async::rt::sleep::Sleep;
-1131
 /* FluentClientGenerator.kt:261 */
 pub(crate) fn base_client_runtime_plugins(mut config: crate::Config) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
     let mut configured_plugins = ::std::vec::Vec::new();
     ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
     #[cfg(feature = "behavior-version-latest")]
-1137
+    {
         if config.behavior_version.is_none() {
             config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
-1140
+        }
-1141
+    }
-1142
     let default_retry_partition = "namingobstaclecoursestructs";
-1144
     let scope = "naming_test_structs";
-1146
     let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
                         // defaults
                         .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
                             ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
                                 .with_retry_partition_name(default_retry_partition)
                                 .with_behavior_version(config.behavior_version.expect("Invalid client configuration: A behavior major version must be set when sending a request or constructing a client. You must set it during client construction or by enabling the `behavior-version-latest` cargo feature."))
                         ))
                         // user config
                         .with_client_plugin(
                             ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
                                 .with_config(config.config.clone())
                                 .with_runtime_components(config.runtime_components.clone())
-1159
+                        )
                         // codegen config
                         .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
                         .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
                         .with_client_plugin(
                             ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
                                 .with_scope(scope)
                                 .with_time_source(config.runtime_components.time_source().unwrap_or_default())
                                 .build()
                                 .expect("All required fields have been set")
                         );
-1170
     for plugin in configured_plugins {
         plugins = plugins.with_client_plugin(plugin);
-1173
+    }
     plugins
-1175
+}
-1176
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_types::config_bag::FrozenLayer;
-1179
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
-1182
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin;
-1185
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
-1188
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
-1191
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::http::SharedHttpClient;
-1194
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_async::rt::sleep::SharedAsyncSleep;
-1197
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::identity::SharedIdentityCache;
-1200
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor;
-1203
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::http::HttpClient;
-1206
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::shared::IntoShared;
-1209
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_async::rt::sleep::AsyncSleep;
-1212
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::identity::ResolveCachedIdentity;
-1215
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::interceptors::Intercept;
-1218
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
-1221
 /* ClientReExports.kt:17 */
 pub use ::aws_smithy_types::config_bag::Layer;
-1224
 /// Types needed to configure endpoint resolution.
 /// /* ClientRustModule.kt:121 */Types needed to configure endpoint resolution.
 pub mod endpoint;
-1227
 /// HTTP request and response types.
 /// /* ClientRustModule.kt:121 */HTTP request and response types.
 pub mod http;
-1230
 /// Types needed to implement [`Intercept`](crate::config::Intercept).
 /// /* ClientRustModule.kt:121 */Types needed to implement [`Intercept`](crate::config::Intercept).
 pub mod interceptors;
-1233
 /// Retry configuration.
 /// /* ClientRustModule.kt:121 */Retry configuration.
 pub mod retry;
-1236
 /// Timeout configuration.
 /// /* ClientRustModule.kt:121 */Timeout configuration.
 pub mod timeout;

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

@@ -1,1 +86,107 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ClientRuntimeTypesReExportGenerator.kt:38 */
 pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
 pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
 pub use ::aws_smithy_types::endpoint::Endpoint;
-6
 /* RustType.kt:516 */
 #[cfg(test)]
 mod test {}
 /* EndpointsDecorator.kt:175 */
 mod test {
-11
     /* EndpointsDecorator.kt:175 */
-+
+}
-+
 /* EndpointResolverGenerator.kt:416 */
 /// Endpoint resolver trait specific to this service
 pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
     /// Resolve an endpoint with the given parameters
     fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
-20
     /// Convert this service-specific resolver into a `SharedEndpointResolver`
     ///
     /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
     fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
     where
         Self: Sized + 'static,
-27
+    {
         ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
-29
+    }
-30
+}
-31
 #[derive(Debug)]
 struct DowncastParams<T>(T);
 impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
 where
     T: ResolveEndpoint,
-37
+{
     fn resolve_endpoint<'a>(
         &'a self,
         params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
     ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
         let ep = match params.get::<crate::config::endpoint::Params>() {
             Some(params) => self.0.resolve_endpoint(params),
             None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
         };
         ep
-47
+    }
-48
+}
-49
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 /// Configuration parameters for resolving the correct endpoint
 pub struct Params {}
 /// /* EndpointParamsGenerator.kt:178 */Configuration parameters for resolving the correct endpoint
 /* EndpointParamsGenerator.kt:179 */
 pub struct Params {/* EndpointParamsGenerator.kt:179 */}
 /* EndpointParamsGenerator.kt:188 */
 impl Params {
     /* EndpointParamsGenerator.kt:189 */
     /// Create a builder for [`Params`]
     pub fn builder() -> crate::config::endpoint::ParamsBuilder {
         crate::config::endpoint::ParamsBuilder::default()
-63
+    }
     /* EndpointParamsGenerator.kt:188 */
-65
+}
-66
 /// Builder for [`Params`]
 /// /* EndpointParamsGenerator.kt:234 */Builder for [`Params`]
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
 pub struct ParamsBuilder {}
 /* EndpointParamsGenerator.kt:238 */
 pub struct ParamsBuilder {/* EndpointParamsGenerator.kt:238 */}
 /* EndpointParamsGenerator.kt:246 */
 impl ParamsBuilder {
     /// Consume this builder, creating [`Params`].
     /// /* EndpointParamsGenerator.kt:247 */Consume this builder, creating [`Params`].
     /* EndpointParamsGenerator.kt:248 */
     pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
         /* EndpointParamsGenerator.kt:272 */
         Ok(
             #[allow(clippy::unnecessary_lazy_evaluations)]
             crate::config::endpoint::Params {},
-81
+        )
         /* EndpointParamsGenerator.kt:248 */
-83
+    }
     /* EndpointParamsGenerator.kt:246 */
-85
+}
-86
 /* EndpointParamsGenerator.kt:139 */
 /// An error that occurred during endpoint resolution
 #[derive(Debug)]
 pub struct InvalidParams {
     field: std::borrow::Cow<'static, str>,
-92
+}
-93
 impl InvalidParams {
     #[allow(dead_code)]
     fn missing(field: &'static str) -> Self {
         Self { field: field.into() }

↧ Expand context

-98
+    }
-99
+}
-100
 impl std::fmt::Display for InvalidParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "a required field was missing: `{}`", self.field)
-104
+    }
-105
+}
-106
 impl std::error::Error for InvalidParams {}

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

@@ -1,1 +3,4 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ClientRuntimeTypesReExportGenerator.kt:60 */
 pub use ::aws_smithy_runtime_api::client::orchestrator::HttpRequest;
 pub use ::aws_smithy_runtime_api::client::orchestrator::HttpResponse;

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

@@ -1,1 +11,12 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ClientRuntimeTypesReExportGenerator.kt:70 */
 pub use ::aws_smithy_runtime_api::client::interceptors::context::AfterDeserializationInterceptorContextRef;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeDeserializationInterceptorContextMut;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeDeserializationInterceptorContextRef;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextMut;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextMut;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextRef;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::FinalizerInterceptorContextMut;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::FinalizerInterceptorContextRef;
 pub use ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;

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

@@ -1,1 +7,9 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ClientRuntimeTypesReExportGenerator.kt:48 */
 pub use ::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry;
 pub use ::aws_smithy_runtime_api::client::retries::classifiers::RetryAction;
 pub use ::aws_smithy_runtime_api::client::retries::ShouldAttempt;
-6
 pub use ::aws_smithy_runtime::client::retries::RetryPartition;
 /* ResiliencyConfigCustomization.kt:324 */
 /* ResiliencyConfigCustomization.kt:329 */ pub use ::aws_smithy_runtime::client::retries::RetryPartition;
 pub use ::aws_smithy_types::retry::{ReconnectMode, RetryConfig, RetryConfigBuilder, RetryMode};

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

@@ -1,1 +2,3 @@

    1      1

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

           2  +

/* ResiliencyConfigCustomization.kt:335 */

    2      3

pub use ::aws_smithy_types::timeout::{TimeoutConfig, TimeoutConfigBuilder};

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

@@ -1,1 +13,15 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ClientRuntimeTypesReExportGenerator.kt:96 */
 pub use ::aws_smithy_runtime_api::box_error::BoxError;
-4
 /* RequiredCustomizations.kt:104 */
 /// Error type returned by the client.
 pub type SdkError<E, R = ::aws_smithy_runtime_api::client::orchestrator::HttpResponse> = ::aws_smithy_runtime_api::client::result::SdkError<E, R>;
 pub use ::aws_smithy_runtime_api::client::result::ConnectorError;
 pub use ::aws_smithy_types::error::operation::BuildError;
-10
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::error::metadata::ErrorMetadata;
 pub use ::aws_smithy_types::error::metadata::ProvideErrorMetadata;
-14
 pub(crate) mod sealed_unhandled;

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

@@ -1,1 +20,21 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServiceErrorGenerator.kt:277 */
 /// This struct is not intended to be used.
 ///
 /// This struct holds information about an unhandled error,
 /// but that information should be obtained by using the
 /// [`ProvideErrorMetadata`](::aws_smithy_types::error::metadata::ProvideErrorMetadata) trait
 /// on the error type.
 ///
 /// This struct intentionally doesn't yield any useful information itself.
 #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
 variable wildcard pattern and check `.code()`:

↧ Expand context

-13
+ \
 &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-15
+ \
 See [`ProvideErrorMetadata`](::aws_smithy_types::error::metadata::ProvideErrorMetadata) for what information is available for the error.")]
 #[derive(Debug)]
 pub struct Unhandled {
     pub(crate) source: ::aws_smithy_runtime_api::box_error::BoxError,
     pub(crate) meta: ::aws_smithy_types::error::metadata::ErrorMetadata,
-21
+}

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

@@ -1,1 +70,104 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServiceErrorGenerator.kt:252 */
 /// All possible error types for this service.
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum Error {
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
 pub /* ServiceErrorGenerator.kt:257 */ enum Error {
     /// /* ServiceErrorGenerator.kt:264 */An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     /* ServiceErrorGenerator.kt:320 */
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-13
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-15
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-Error) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
     /* ServiceErrorGenerator.kt:266 */
     Unhandled(crate::error::sealed_unhandled::Unhandled), /* ServiceErrorGenerator.kt:257 */
-19
+}
 /* ServiceErrorGenerator.kt:131 */
 impl ::std::fmt::Display for Error {
     /* ServiceErrorGenerator.kt:132 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServiceErrorGenerator.kt:133 */
         match self {
             /* ServiceErrorGenerator.kt:137 */
             Error::Unhandled(_) => {
                 if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
                     write!(f, "unhandled error ({code})")
                 } else {
                     f.write_str("unhandled error")
-32
+                }
             } /* ServiceErrorGenerator.kt:133 */
-34
+        }
         /* ServiceErrorGenerator.kt:132 */
-36
+    }
--
+    }
     /* ServiceErrorGenerator.kt:131 */
-38
+}
 /* ServiceErrorGenerator.kt:154 */
 impl From<::aws_smithy_types::error::operation::BuildError> for Error {
     fn from(value: ::aws_smithy_types::error::operation::BuildError) -> Self {
         Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: value.into(),
             meta: ::std::default::Default::default(),
         })
-46
+    }
-47
+}
 /* ServiceErrorGenerator.kt:223 */
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for Error {
     fn meta(&self) -> &::aws_smithy_types::error::metadata::ErrorMetadata {
         match self {
             Self::Unhandled(inner) => &inner.meta,
-53
+        }
-54
+    }
-55
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::structs::StructsError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-60
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::structs::StructsError, R>) -> Self {
         /* ServiceErrorGenerator.kt:184 */
         match err {
             /* ServiceErrorGenerator.kt:185 */
             ::aws_smithy_runtime_api::client::result::SdkError::ServiceError(context) => Self::from(context.into_err()),
             /* ServiceErrorGenerator.kt:186 */
             _ => Error::Unhandled(crate::error::sealed_unhandled::Unhandled {
                 meta: ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(&err).clone(),
                 source: err.into(),
             }),
             /* ServiceErrorGenerator.kt:184 */
-73
+        }
         /* ServiceErrorGenerator.kt:179 */
-75
+    }
     /* ServiceErrorGenerator.kt:174 */
-77
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::structs::StructsError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::structs::StructsError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::structs::StructsError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-87
+        }
         /* ServiceErrorGenerator.kt:203 */
-89
+    }
     /* ServiceErrorGenerator.kt:202 */
-91
+}
 /* ServiceErrorGenerator.kt:115 */
 impl ::std::error::Error for Error {
     /* ServiceErrorGenerator.kt:116 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServiceErrorGenerator.kt:117 */
         match self {
             Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source),
             /* ServiceErrorGenerator.kt:121 */
             Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source), /* ServiceErrorGenerator.kt:117 */
-100
+        }
         /* ServiceErrorGenerator.kt:116 */
-102
+    }
     /* ServiceErrorGenerator.kt:115 */
-104
+}

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

@@ -18,18 +112,121 @@

↥ Expand context

 #![forbid(unsafe_code)]
 #![warn(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 //! Confounds model generation machinery with lots of problematic names
 //!
 //! # Crate Organization
 //!
 //! The entry point for most customers will be [`Client`], which exposes one method for each API
 //! offered by the service. The return value of each of these methods is a "fluent builder",
 //! where the different inputs for that API are added by builder-style function call chaining,
 //! followed by calling `send()` to get a [`Future`](std::future::Future) that will result in
 //! either a successful output or a [`SdkError`](crate::error::SdkError).
 //!
 //! Some of these API inputs may be structs or enums to provide more complex structured information.
 //! These structs and enums live in [`types`](crate::types). There are some simpler types for
 //! representing data such as date times or binary blobs that live in [`primitives`](crate::primitives).
 //!
 //! All types required to configure a client via the [`Config`](crate::Config) struct live
 //! in [`config`](crate::config).
 //!

 //! The [`operation`](crate::operation) module has a submodule for every API, and in each submodule
 //! is the input, output, and error type for that API, as well as builders to construct each of those.
 //!
 //! There is a top-level [`Error`](crate::Error) type that encompasses all the errors that the
 //! client can return. Any other error type can be converted to this `Error` type via the
 //! [`From`](std::convert::From) trait.
 //!
 //! The other modules within this crate are not required for normal usage.
-46
 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServiceErrorGenerator.kt:127 */
 pub use error_meta::Error;
-50
 /* RustType.kt:516 */
 #[doc(inline)]
 /* ServiceGenerator.kt:63 */
 pub use config::Config;
-55
 /// Client for calling the service.
 /// /* FluentClientDocs.kt:24 */Client for calling the service.
 ///
 /// ## Constructing a `Client`
 ///
 /// A `Client` requires a config in order to be constructed. With the default set of Cargo features,
 /// this config will only require an endpoint to produce a functioning client. However, some Smithy
 /// features will require additional configuration. For example, `@auth` requires some kind of identity
 /// or identity resolver to be configured. The config is used to customize various aspects of the client,
 /// such as:
 ///
 ///   - [The underlying HTTP client](crate::config::Builder::http_client)
 ///   - [Retries](crate::config::Builder::retry_config)
 ///   - [Timeouts](crate::config::Builder::timeout_config)
 ///   - [... and more](crate::config::Builder)
 ///
 /// Below is a minimal example of how to create a client:
 ///
 /// ```rust,no_run
 /// let config = naming_test_structs::Config::builder()
 ///     .endpoint_url("http://localhost:1234")
 ///     .build();
 /// let client = naming_test_structs::Client::from_conf(config);
 /// ```
 ///
 /// _Note:_ Client construction is expensive due to connection thread pool initialization, and should be done
 /// once at application start-up. Cloning a client is cheap (it's just an [`Arc`](std::sync::Arc) under the hood),
 /// so creating it once at start-up and cloning it around the application as needed is recommended.
 pub mod client;
-84
 /// Configuration for the service.
 /// /* ClientRustModule.kt:121 */Configuration for the service.
 pub mod config;
-87
 /// Common errors and error handling utilities.
 /// /* ClientRustModule.kt:121 */Common errors and error handling utilities.
 pub mod error;
-90
 /* RustModule.kt:172 */
 mod error_meta;
-93
 /// Information about this crate.
 /// /* ClientRustModule.kt:121 */Information about this crate.
 pub mod meta;
-96
 /// Primitives such as `Blob` or `DateTime` used by other types.
 /// /* ClientRustModule.kt:121 */Primitives such as `Blob` or `DateTime` used by other types.
 pub mod primitives;
-99
 /// Data structures used by operation inputs/outputs.
 /// /* ClientRustModule.kt:121 */Data structures used by operation inputs/outputs.
 pub mod types;
-102
 /* RustModule.kt:172 */
 mod auth_plugin;
-105
 /// All operations that this crate can perform.
 /// /* ClientRustModule.kt:121 */All operations that this crate can perform.
 pub mod operation;
-108
 pub(crate) mod protocol_serde;
-110
 /* RustModule.kt:172 */
 mod sdk_feature_tracker;
-113
 /* RustModule.kt:172 */
 mod serialization_settings;
-116
 /* RustModule.kt:172 */
 mod json_errors;
-119
 /* FluentClientDecorator.kt:76 */
 pub use client::Client;

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

@@ -1,1 +4,5 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /* CrateVersionCustomization.kt:23 */
 /// Crate version number.
 pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

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

@@ -1,1 +4,4 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// Types for the `Structs` operation.
 /* CodegenDelegator.kt:51 */
 /// /* CodegenDelegator.kt:51 */Types for the `Structs` operation.
 pub mod structs;

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

@@ -1,1 +40,49 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* OperationGenerator.kt:77 */
 /// Orchestration and serialization glue logic for `Structs`.
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* OperationGenerator.kt:84 */
 pub struct Structs;
 /* OperationGenerator.kt:85 */
 impl Structs {
     /// Creates a new `Structs`
     /// /* OperationGenerator.kt:86 */Creates a new `Structs`
     /* OperationGenerator.kt:87 */
     pub fn new() -> Self {
         /* OperationGenerator.kt:88 */
         Self
         /* OperationGenerator.kt:87 */
-18
+    }
     /* OperationGenerator.kt:138 */
     pub(crate) async fn orchestrate(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::structs::StructsInput,
     ) -> ::std::result::Result<
         crate::operation::structs::StructsOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::structs::StructsError,
             ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         >,
     > {

↧ Expand context

         let map_err =
             |err: ::aws_smithy_runtime_api::client::result::SdkError<
                 ::aws_smithy_runtime_api::client::interceptors::context::Error,
                 ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
             >| { err.map_service_error(|err| err.downcast::<crate::operation::structs::StructsError>().expect("correct error type")) };
         let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
             .await
             .map_err(map_err)?;
         let output = context.finalize().map_err(map_err)?;
         ::std::result::Result::Ok(
             output
                 .downcast::<crate::operation::structs::StructsOutput>()
                 .expect("correct output type"),
-43
+        )
-44
+    }
-45
     pub(crate) async fn orchestrate_with_stop_point(
         runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         input: crate::operation::structs::StructsInput,
         stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,

@@ -59,68 +334,405 @@

↥ Expand context

         .instrument(::tracing::debug_span!(
             "NamingObstacleCourseStructs.Structs",
             "rpc.service" = "NamingObstacleCourseStructs",
             "rpc.method" = "Structs",
             "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
         ))
         .await
-75
+    }
-76
     pub(crate) fn operation_runtime_plugins(
         client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
         client_config: &crate::config::Config,
         config_override: ::std::option::Option<crate::config::Builder>,
     ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
         let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
         runtime_plugins = runtime_plugins.with_client_plugin(crate::auth_plugin::DefaultAuthOptionsPlugin::new(vec![
             ::aws_smithy_runtime::client::auth::no_auth::NO_AUTH_SCHEME_ID,
         ]));
         if let ::std::option::Option::Some(config_override) = config_override {
             for plugin in config_override.runtime_plugins.iter().cloned() {

                 runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
-89
+            }
             runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
                 config_override,
                 client_config.config.clone(),
                 &client_config.runtime_components,
             ));
-95
+        }
         runtime_plugins
-97
+    }
     /* OperationGenerator.kt:85 */
-99
+}
 /* OperationRuntimePluginGenerator.kt:55 */
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for Structs {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Structs");
-104
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
             StructsRequestSerializer,
         ));
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             StructsResponseDeserializer,
         ));
-111
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-115
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "Structs",
             "NamingObstacleCourseStructs",
         ));
-120
         ::std::option::Option::Some(cfg.freeze())
-122
+    }
-123
     fn runtime_components(
         &self,
         _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
     ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         #[allow(unused_mut)]
         let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("Structs")
             .with_interceptor(::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default())
             .with_interceptor(StructsEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::structs::StructsError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::structs::StructsError,
             >::new());
-138
         ::std::borrow::Cow::Owned(rcb)
-140
+    }
-141
+}
-142
 /* ResponseDeserializerGenerator.kt:64 */
 #[derive(Debug)]
 struct StructsResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for StructsResponseDeserializer {
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         let (success, status) = (response.status().is_success(), response.status().as_u16());
         let headers = response.headers();
         let body = response.body().bytes().expect("body loaded");
         #[allow(unused_mut)]
         let mut force_error = false;
-156
         let parse_result = if !success && status != 200 || force_error {
             crate::protocol_serde::shape_structs::de_structs_http_error(status, headers, body)
         } else {
             crate::protocol_serde::shape_structs::de_structs_http_response(status, headers, body)
         };
         crate::protocol_serde::type_erase_result(parse_result)
-163
+    }
-164
+}
 /* RequestSerializerGenerator.kt:67 */
 #[derive(Debug)]
 struct StructsRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for StructsRequestSerializer {
     #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
     fn serialize_input(
         &self,
         input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         let input = input.downcast::<crate::operation::structs::StructsInput>().expect("correct type");
         let _header_serialization_settings = _cfg
             .load::<crate::serialization_settings::HeaderSerializationSettings>()
             .cloned()
             .unwrap_or_default();
         let mut request_builder = {
             fn uri_base(
                 _input: &crate::operation::structs::StructsInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 ::std::write!(output, "/").expect("formatting should succeed");
                 ::std::result::Result::Ok(())
-188
+            }
             #[allow(clippy::unnecessary_wraps)]
             fn update_http_builder(
                 input: &crate::operation::structs::StructsInput,
                 builder: ::http::request::Builder,
             ) -> ::std::result::Result<::http::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
                 let mut uri = ::std::string::String::new();
                 uri_base(input, &mut uri)?;
                 ::std::result::Result::Ok(builder.method("POST").uri(uri))
-197
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/x-amz-json-1.1");
             builder = _header_serialization_settings.set_default_header(
                 builder,
                 ::http::header::HeaderName::from_static("x-amz-target"),
                 "NamingObstacleCourseStructs.Structs",
             );
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_structs::ser_structs_input(&input)?);
         if let Some(content_length) = body.content_length() {
             let content_length = content_length.to_string();
             request_builder = _header_serialization_settings.set_default_header(request_builder, ::http::header::CONTENT_LENGTH, &content_length);
-211
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-213
+    }
-214
+}
 /* EndpointParamsInterceptorGenerator.kt:86 */
 #[derive(Debug)]
 struct StructsEndpointParamsInterceptor;
-218
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for StructsEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "StructsEndpointParamsInterceptor"
-222
+    }
-223
     fn read_before_execution(
         &self,
         context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
             '_,
             ::aws_smithy_runtime_api::client::interceptors::context::Input,
             ::aws_smithy_runtime_api::client::interceptors::context::Output,
             ::aws_smithy_runtime_api::client::interceptors::context::Error,
         >,
         cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
     ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         let _input = context
             .input()
             .downcast_ref::<StructsInput>()
             .ok_or("failed to downcast to StructsInput")?;
-238
         let params = crate::config::endpoint::Params::builder().build().map_err(|err| {
             ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         })?;
         cfg.interceptor_state()
             .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         ::std::result::Result::Ok(())
-245
+    }
-246
+}
-247
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-250
 /* OperationErrorGenerator.kt:79 */
 /// Error type for the `StructsError` operation.
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum StructsError {
 pub /* OperationErrorGenerator.kt:81 */ enum StructsError {
     /* OperationErrorGenerator.kt:88 */
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
     variable wildcard pattern and check `.code()`:
-262
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-264
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-StructsError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
     /* OperationErrorGenerator.kt:81 */
-268
+}
 /* OperationErrorGenerator.kt:218 */
 impl StructsError {
     /* OperationErrorGenerator.kt:219 */
     /// Creates the `StructsError::Unhandled` variant from any error type.
     pub fn unhandled(
         err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
     ) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.into(),
             meta: ::std::default::Default::default(),
         })
-280
+    }
-281
     /// Creates the `StructsError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
     pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source: err.clone().into(),
             meta: err,
         })
-288
+    }
     ///
     /// /* OperationErrorGenerator.kt:236 */
     /// Returns error metadata, which includes the error code, message,
     /// request ID, and potentially additional information.
     ///
     /* OperationErrorGenerator.kt:242 */
     pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         /* OperationErrorGenerator.kt:243 */
         match self {
             Self::Unhandled(e) => &e.meta,
             /* OperationErrorGenerator.kt:251 */ Self::Unhandled(e) => &e.meta,
             /* OperationErrorGenerator.kt:243 */
-299
+        }
         /* OperationErrorGenerator.kt:242 */
-301
+    }
     /* OperationErrorGenerator.kt:218 */
-303
+}
 /* OperationErrorGenerator.kt:269 */
 impl ::std::error::Error for StructsError {
     /* OperationErrorGenerator.kt:270 */
     fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* OperationErrorGenerator.kt:318 */
         match self {
             Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
             /* OperationErrorGenerator.kt:326 */
             Self::Unhandled(_inner) => {
                 /* OperationErrorGenerator.kt:279 */
                 ::std::option::Option::Some(&*_inner.source)
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-316
+        }
         /* OperationErrorGenerator.kt:270 */
-318
+    }
     /* OperationErrorGenerator.kt:269 */
-320
+}
 /* OperationErrorGenerator.kt:133 */
 impl ::std::fmt::Display for StructsError {
     /* OperationErrorGenerator.kt:134 */
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         /* OperationErrorGenerator.kt:318 */
         match self {
             /* OperationErrorGenerator.kt:326 */
             Self::Unhandled(_inner) => {
                 /* OperationErrorGenerator.kt:139 */
                 if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
                     write!(f, "unhandled error ({code})")
                 } else {
                     f.write_str("unhandled error")
-334
+                }
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-337
+        }
         /* OperationErrorGenerator.kt:134 */
-339
+    }
--
+    }
     /* OperationErrorGenerator.kt:133 */
-341
+}
 /* OperationErrorGenerator.kt:182 */
 impl ::aws_smithy_types::retry::ProvideErrorKind for StructsError {
     /* OperationErrorGenerator.kt:186 */
     fn code(&self) -> ::std::option::Option<&str> {
         /* OperationErrorGenerator.kt:187 */
         ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
         /* OperationErrorGenerator.kt:186 */
-349
+    }
     /* OperationErrorGenerator.kt:190 */
     fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
         /* OperationErrorGenerator.kt:197 */
         ::std::option::Option::None
         /* OperationErrorGenerator.kt:190 */
-355
+    }
     /* OperationErrorGenerator.kt:182 */
-357
+}
 /* OperationErrorGenerator.kt:163 */
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for StructsError {
     /* OperationErrorGenerator.kt:164 */
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         /* OperationErrorGenerator.kt:318 */
         match self {
             Self::Unhandled(_inner) => &_inner.meta,
             /* OperationErrorGenerator.kt:326 */
             Self::Unhandled(_inner) => {
                 /* OperationErrorGenerator.kt:168 */
                 &_inner.meta
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-370
+        }
         /* OperationErrorGenerator.kt:164 */
-372
+    }
     /* OperationErrorGenerator.kt:163 */
-374
+}
 /* OperationErrorGenerator.kt:109 */
 impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for StructsError {
     /* OperationErrorGenerator.kt:110 */
     fn create_unhandled_error(
         source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
         meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
     ) -> Self {
         /* OperationErrorGenerator.kt:121 */
         Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
             source,
             meta: meta.unwrap_or_default(),
         })
         /* OperationErrorGenerator.kt:110 */
-388
+    }
     /* OperationErrorGenerator.kt:109 */
-390
+}
-391
 /* CodegenDelegator.kt:255 */
 pub use crate::operation::structs::_structs_output::StructsOutput;
-394
 /* CodegenDelegator.kt:255 */
 pub use crate::operation::structs::_structs_input::StructsInput;
-397
 /* RustModule.kt:172 */
 mod _structs_input;
-400
 /* RustModule.kt:172 */
 mod _structs_output;
-403
 /// Builders
 /// /* CodegenDelegator.kt:51 */Builders
 pub mod builders;

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291