Client Test

tmp-codegen-diff/codegen-client-test/pokemon-service-client/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 pokemon_service_client service client.
 /* ServiceConfigGenerator.kt:409 */
 /// /* ServiceConfigGenerator.kt:409 */Configuration for a pokemon_service_client 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 pokemon_service_client::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 pokemon_service_client::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 = pokemon_service_client::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 pokemon_service_client::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 = pokemon_service_client::Config::builder().endpoint_resolver(resolver).build();
     /// let client = pokemon_service_client::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 pokemon_service_client::config::Config;
     /// use pokemon_service_client::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 pokemon_service_client::config::{Builder, Config};
     /// use pokemon_service_client::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 pokemon_service_client::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 pokemon_service_client::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 pokemon_service_client::config::Config;
     /// use pokemon_service_client::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 pokemon_service_client::config::{Builder, Config};
     /// use pokemon_service_client::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 pokemon_service_client::config::IdentityCache;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .identity_cache(IdentityCache::no_cache())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing lazy caching:
     /// ```no_run
     /// use pokemon_service_client::config::IdentityCache;
     /// use std::time::Duration;
     ///
     /// let config = pokemon_service_client::Config::builder()

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

↥ Expand context

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

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

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

↥ Expand context

     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::latest())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
     ///
     /// Customizing behavior major version:
     /// ```no_run
     /// use pokemon_service_client::config::BehaviorVersion;
     ///
     /// let config = pokemon_service_client::Config::builder()
     ///     .behavior_version(BehaviorVersion::v2023_11_09())
     ///     // ...
     ///     .build();
     /// let client = pokemon_service_client::Client::from_conf(config);
     /// ```
-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("pokemon_service_client::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("PokemonService");
             cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
             ::std::option::Option::Some(cfg.freeze())
         };
         let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
         runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
         runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
         runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
         Self { config, runtime_components }
-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("pokemon_service_client::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 = "pokemonservice";
-1144
     let scope = "pokemon-service-client";
-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/pokemon-service-client/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 Pokémon 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/pokemon-service-client/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/pokemon-service-client/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/pokemon-service-client/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/pokemon-service-client/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/pokemon-service-client/rust-client-codegen/src/error.rs

@@ -1,1 +30,33 @@

 // 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
 /* ClientEnumGenerator.kt:302 */
 /// The given enum value failed to parse since it is not a known value.
 #[derive(Debug)]
 pub struct UnknownVariantError {
     value: ::std::string::String,
-20
+}
 impl UnknownVariantError {
     pub(crate) fn new(value: impl ::std::convert::Into<::std::string::String>) -> Self {
         Self { value: value.into() }
-24
+    }
-25
+}

↧ Expand context

 impl ::std::fmt::Display for UnknownVariantError {
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::result::Result<(), ::std::fmt::Error> {
         write!(f, "unknown enum variant: '{}'", self.value)
-29
+    }
-30
+}
 impl ::std::error::Error for UnknownVariantError {}
-32
 pub(crate) mod sealed_unhandled;

tmp-codegen-diff/codegen-client-test/pokemon-service-client/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/pokemon-service-client/rust-client-codegen/src/error_meta.rs

@@ -1,1 +286,465 @@

 // 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 {
 pub /* ServiceErrorGenerator.kt:257 */ enum Error {
     /* ServiceErrorGenerator.kt:259 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServiceErrorGenerator.kt:262 */
     InvalidPokeballError(crate::types::error::InvalidPokeballError),
     /* ServiceErrorGenerator.kt:259 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServiceErrorGenerator.kt:262 */
     MasterBallUnsuccessful(crate::types::error::MasterBallUnsuccessful),
     /* ServiceErrorGenerator.kt:259 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServiceErrorGenerator.kt:262 */
     ResourceNotFoundError(crate::types::error::ResourceNotFoundError),
     /// Not authorized to access Pokémon storage.
     /// /* ServiceErrorGenerator.kt:259 */Not authorized to access Pokémon storage.
     /* ServiceErrorGenerator.kt:262 */
     StorageAccessNotAuthorized(crate::types::error::StorageAccessNotAuthorized),
     /* ServiceErrorGenerator.kt:259 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServiceErrorGenerator.kt:262 */
     ThrottlingError(crate::types::error::ThrottlingError),
     /* ServiceErrorGenerator.kt:259 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServiceErrorGenerator.kt:262 */
     UnsupportedRegionError(crate::types::error::UnsupportedRegionError),
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /// /* ServiceErrorGenerator.kt:259 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /* ServiceErrorGenerator.kt:262 */
     ValidationError(crate::types::error::ValidationError),
     /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
     /// /* 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()`:
-39
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-41
+     \
     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 */
-45
+}
 /* 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 {
             Error::InvalidPokeballError(inner) => inner.fmt(f),
             Error::MasterBallUnsuccessful(inner) => inner.fmt(f),
             Error::ResourceNotFoundError(inner) => inner.fmt(f),
             Error::StorageAccessNotAuthorized(inner) => inner.fmt(f),
             Error::ThrottlingError(inner) => inner.fmt(f),
             Error::UnsupportedRegionError(inner) => inner.fmt(f),
             Error::ValidationError(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::InvalidPokeballError(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::MasterBallUnsuccessful(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::ResourceNotFoundError(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::StorageAccessNotAuthorized(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::ThrottlingError(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::UnsupportedRegionError(inner) => inner.fmt(f),
             /* ServiceErrorGenerator.kt:135 */ Error::ValidationError(inner) => inner.fmt(f),
             /* 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")
-65
+                }
             } /* ServiceErrorGenerator.kt:133 */
-67
+        }
         /* ServiceErrorGenerator.kt:132 */
-69
+    }
--
+    }
     /* ServiceErrorGenerator.kt:131 */
-71
+}
 /* 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(),
         })
-79
+    }
-80
+}
 /* ServiceErrorGenerator.kt:223 */
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for Error {
     fn meta(&self) -> &::aws_smithy_types::error::metadata::ErrorMetadata {
         match self {
             Self::InvalidPokeballError(inner) => inner.meta(),
             Self::MasterBallUnsuccessful(inner) => inner.meta(),
             Self::ResourceNotFoundError(inner) => inner.meta(),
             Self::StorageAccessNotAuthorized(inner) => inner.meta(),
             Self::ThrottlingError(inner) => inner.meta(),
             Self::UnsupportedRegionError(inner) => inner.meta(),
             Self::ValidationError(inner) => inner.meta(),
             Self::Unhandled(inner) => &inner.meta,
-93
+        }
-94
+    }
-95
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::capture_pokemon::CapturePokemonError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-100
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::capture_pokemon::CapturePokemonError, 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 */
-113
+        }
         /* ServiceErrorGenerator.kt:179 */
-115
+    }
     /* ServiceErrorGenerator.kt:174 */
-117
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::capture_pokemon::CapturePokemonError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::capture_pokemon::CapturePokemonError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::capture_pokemon::CapturePokemonError::ValidationError(inner) => Error::ValidationError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::capture_pokemon::CapturePokemonError::MasterBallUnsuccessful(inner) => Error::MasterBallUnsuccessful(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::capture_pokemon::CapturePokemonError::InvalidPokeballError(inner) => Error::InvalidPokeballError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::capture_pokemon::CapturePokemonError::ThrottlingError(inner) => Error::ThrottlingError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::capture_pokemon::CapturePokemonError::UnsupportedRegionError(inner) => Error::UnsupportedRegionError(inner),
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::capture_pokemon::CapturePokemonError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-137
+        }
         /* ServiceErrorGenerator.kt:203 */
-139
+    }
     /* ServiceErrorGenerator.kt:202 */
-141
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::check_health::CheckHealthError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-146
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::check_health::CheckHealthError, 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 */
-159
+        }
         /* ServiceErrorGenerator.kt:179 */
-161
+    }
     /* ServiceErrorGenerator.kt:174 */
-163
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::check_health::CheckHealthError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::check_health::CheckHealthError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::check_health::CheckHealthError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-173
+        }
         /* ServiceErrorGenerator.kt:203 */
-175
+    }
     /* ServiceErrorGenerator.kt:202 */
-177
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::do_nothing::DoNothingError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-182
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::do_nothing::DoNothingError, 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 */
-195
+        }
         /* ServiceErrorGenerator.kt:179 */
-197
+    }
     /* ServiceErrorGenerator.kt:174 */
-199
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::do_nothing::DoNothingError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::do_nothing::DoNothingError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::do_nothing::DoNothingError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-209
+        }
         /* ServiceErrorGenerator.kt:203 */
-211
+    }
     /* ServiceErrorGenerator.kt:202 */
-213
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_pokemon_species::GetPokemonSpeciesError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-218
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_pokemon_species::GetPokemonSpeciesError, 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 */
-231
+        }
         /* ServiceErrorGenerator.kt:179 */
-233
+    }
     /* ServiceErrorGenerator.kt:174 */
-235
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::get_pokemon_species::GetPokemonSpeciesError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::get_pokemon_species::GetPokemonSpeciesError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::get_pokemon_species::GetPokemonSpeciesError::ValidationError(inner) => Error::ValidationError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::get_pokemon_species::GetPokemonSpeciesError::ResourceNotFoundError(inner) => Error::ResourceNotFoundError(inner),
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::get_pokemon_species::GetPokemonSpeciesError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-249
+        }
         /* ServiceErrorGenerator.kt:203 */
-251
+    }
     /* ServiceErrorGenerator.kt:202 */
-253
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_server_statistics::GetServerStatisticsError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-258
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_server_statistics::GetServerStatisticsError, 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 */
-271
+        }
         /* ServiceErrorGenerator.kt:179 */
-273
+    }
     /* ServiceErrorGenerator.kt:174 */
-275
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::get_server_statistics::GetServerStatisticsError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::get_server_statistics::GetServerStatisticsError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::get_server_statistics::GetServerStatisticsError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-285
+        }
         /* ServiceErrorGenerator.kt:203 */
-287
+    }
     /* ServiceErrorGenerator.kt:202 */
-289
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_storage::GetStorageError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-294
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::get_storage::GetStorageError, 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 */
-307
+        }
         /* ServiceErrorGenerator.kt:179 */
-309
+    }
     /* ServiceErrorGenerator.kt:174 */
-311
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::get_storage::GetStorageError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::get_storage::GetStorageError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::get_storage::GetStorageError::ValidationError(inner) => Error::ValidationError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::get_storage::GetStorageError::StorageAccessNotAuthorized(inner) => Error::StorageAccessNotAuthorized(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::operation::get_storage::GetStorageError::ResourceNotFoundError(inner) => Error::ResourceNotFoundError(inner),
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::get_storage::GetStorageError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-327
+        }
         /* ServiceErrorGenerator.kt:203 */
-329
+    }
     /* ServiceErrorGenerator.kt:202 */
-331
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::operation::stream_pokemon_radio::StreamPokemonRadioError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-336
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::operation::stream_pokemon_radio::StreamPokemonRadioError, 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 */
-349
+        }
         /* ServiceErrorGenerator.kt:179 */
-351
+    }
     /* ServiceErrorGenerator.kt:174 */
-353
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::operation::stream_pokemon_radio::StreamPokemonRadioError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::operation::stream_pokemon_radio::StreamPokemonRadioError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:212 */
             crate::operation::stream_pokemon_radio::StreamPokemonRadioError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-363
+        }
         /* ServiceErrorGenerator.kt:203 */
-365
+    }
     /* ServiceErrorGenerator.kt:202 */
-367
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::types::error::AttemptCapturingPokemonEventError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-372
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::types::error::AttemptCapturingPokemonEventError, 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 */
-385
+        }
         /* ServiceErrorGenerator.kt:179 */
-387
+    }
     /* ServiceErrorGenerator.kt:174 */
-389
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::types::error::AttemptCapturingPokemonEventError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::types::error::AttemptCapturingPokemonEventError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:207 */
             crate::types::error::AttemptCapturingPokemonEventError::MasterBallUnsuccessful(inner) => Error::MasterBallUnsuccessful(inner),
             /* ServiceErrorGenerator.kt:212 */
             crate::types::error::AttemptCapturingPokemonEventError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-401
+        }
         /* ServiceErrorGenerator.kt:203 */
-403
+    }
     /* ServiceErrorGenerator.kt:202 */
-405
+}
 /* ServiceErrorGenerator.kt:174 */
 impl<R> From<::aws_smithy_runtime_api::client::result::SdkError<crate::types::error::CapturePokemonEventsError, R>> for Error
 where
     R: Send + Sync + std::fmt::Debug + 'static,
-410
+{
     /* ServiceErrorGenerator.kt:179 */
     fn from(err: ::aws_smithy_runtime_api::client::result::SdkError<crate::types::error::CapturePokemonEventsError, 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 */
-423
+        }
         /* ServiceErrorGenerator.kt:179 */
-425
+    }
     /* ServiceErrorGenerator.kt:174 */
-427
+}
 /* ServiceErrorGenerator.kt:202 */
 impl From<crate::types::error::CapturePokemonEventsError> for Error {
     /* ServiceErrorGenerator.kt:203 */
     fn from(err: crate::types::error::CapturePokemonEventsError) -> Self {
         /* ServiceErrorGenerator.kt:204 */
         match err {
             /* ServiceErrorGenerator.kt:207 */
             crate::types::error::CapturePokemonEventsError::InvalidPokeballError(inner) => Error::InvalidPokeballError(inner),
             /* ServiceErrorGenerator.kt:207 */
             crate::types::error::CapturePokemonEventsError::ThrottlingError(inner) => Error::ThrottlingError(inner),
             /* ServiceErrorGenerator.kt:212 */
             crate::types::error::CapturePokemonEventsError::Unhandled(inner) => Error::Unhandled(inner),
             /* ServiceErrorGenerator.kt:204 */
-441
+        }
         /* ServiceErrorGenerator.kt:203 */
-443
+    }
     /* ServiceErrorGenerator.kt:202 */
-445
+}
 /* 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::InvalidPokeballError(inner) => inner.source(),
             Error::MasterBallUnsuccessful(inner) => inner.source(),
             Error::ResourceNotFoundError(inner) => inner.source(),
             Error::StorageAccessNotAuthorized(inner) => inner.source(),
             Error::ThrottlingError(inner) => inner.source(),
             Error::UnsupportedRegionError(inner) => inner.source(),
             Error::ValidationError(inner) => inner.source(),
             Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source),
--
+        }
--
+    }
             /* ServiceErrorGenerator.kt:119 */ Error::InvalidPokeballError(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::MasterBallUnsuccessful(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::ResourceNotFoundError(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::StorageAccessNotAuthorized(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::ThrottlingError(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::UnsupportedRegionError(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:119 */ Error::ValidationError(inner) => inner.source(),
             /* ServiceErrorGenerator.kt:121 */
             Error::Unhandled(inner) => ::std::option::Option::Some(&*inner.source), /* ServiceErrorGenerator.kt:117 */
-+
+        }
         /* ServiceErrorGenerator.kt:116 */
-+
+    }
     /* ServiceErrorGenerator.kt:115 */
-465
+}

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

@@ -1,1 +186,282 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* EventStreamErrorMarshallerGenerator.kt:79 */
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct AttemptCapturingPokemonEventErrorMarshaller;
-6
 impl AttemptCapturingPokemonEventErrorMarshaller {
     pub fn new() -> Self {
         AttemptCapturingPokemonEventErrorMarshaller
-10
+    }
-11
+}
 /* EventStreamErrorMarshallerGenerator.kt:93 */
 impl ::aws_smithy_eventstream::frame::MarshallMessage for AttemptCapturingPokemonEventErrorMarshaller {
     /* EventStreamErrorMarshallerGenerator.kt:97 */
     type Input = crate::types::error::AttemptCapturingPokemonEventError;
     /* EventStreamErrorMarshallerGenerator.kt:99 */
     fn marshall(
         &self,
         _input: Self::Input,
     ) -> std::result::Result<::aws_smithy_types::event_stream::Message, ::aws_smithy_eventstream::error::Error> {
         /* EventStreamErrorMarshallerGenerator.kt:103 */
         let mut headers = Vec::new();
         /* EventStreamMarshallerGenerator.kt:322 */
         headers.push(::aws_smithy_types::event_stream::Header::new(
             ":message-type",
             ::aws_smithy_types::event_stream::HeaderValue::String("exception".into()),
         ));
         /* EventStreamErrorMarshallerGenerator.kt:108 */
         let payload = match _input {
             crate::types::error::AttemptCapturingPokemonEventError::MasterBallUnsuccessful(inner) =>  {
                 headers.push(::aws_smithy_types::event_stream::Header::new(":exception-type", ::aws_smithy_types::event_stream::HeaderValue::String("masterball_unsuccessful".into())));
                 headers.push(::aws_smithy_types::event_stream::Header::new(":content-type", ::aws_smithy_types::event_stream::HeaderValue::String("application/json".into())));
                 crate::protocol_serde::shape_master_ball_unsuccessful::ser_master_ball_unsuccessful_error(&inner)
             /* EventStreamErrorMarshallerGenerator.kt:113 */crate::types::error::AttemptCapturingPokemonEventError::MasterBallUnsuccessful(inner) =>  {
                 /* EventStreamMarshallerGenerator.kt:322 */headers.push(::aws_smithy_types::event_stream::Header::new(":exception-type", ::aws_smithy_types::event_stream::HeaderValue::String("masterball_unsuccessful".into())));
                 /* EventStreamMarshallerGenerator.kt:322 */headers.push(::aws_smithy_types::event_stream::Header::new(":content-type", ::aws_smithy_types::event_stream::HeaderValue::String("application/json".into())));
                 /* EventStreamMarshallerGenerator.kt:283 */crate::protocol_serde::shape_master_ball_unsuccessful::ser_master_ball_unsuccessful_error(&inner)
                                             .map_err(|err| ::aws_smithy_eventstream::error::Error::marshalling(format!("{}", err)))?
--
+            }
             crate::types::error::AttemptCapturingPokemonEventError::Unhandled(_inner) => return Err(
             /* EventStreamErrorMarshallerGenerator.kt:113 */}
             /* EventStreamErrorMarshallerGenerator.kt:119 */crate::types::error::AttemptCapturingPokemonEventError::Unhandled(_inner) => return Err(
                                                 ::aws_smithy_eventstream::error::Error::marshalling("Cannot serialize `AttemptCapturingPokemonEvent::Unknown` for the request. The `Unknown` variant is intended for responses only. It occurs when an outdated client is used after a new enum variant was added on the server side.".to_owned())
                                             ),
--
+        }
--
+        ;
         /* EventStreamErrorMarshallerGenerator.kt:108 */}
         /* EventStreamErrorMarshallerGenerator.kt:131 */;
         Ok(::aws_smithy_types::event_stream::Message::new_from_parts(headers, payload))
         /* EventStreamErrorMarshallerGenerator.kt:99 */
-43
+    }
     /* EventStreamErrorMarshallerGenerator.kt:93 */
-45
+}
-46
 /* EventStreamMarshallerGenerator.kt:115 */
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct AttemptCapturingPokemonEventMarshaller;
-51
 impl AttemptCapturingPokemonEventMarshaller {
     pub fn new() -> Self {
         AttemptCapturingPokemonEventMarshaller
-55
+    }
-56
+}
 /* EventStreamMarshallerGenerator.kt:129 */
 impl ::aws_smithy_eventstream::frame::MarshallMessage for AttemptCapturingPokemonEventMarshaller {
     /* EventStreamMarshallerGenerator.kt:133 */
     type Input = crate::types::AttemptCapturingPokemonEvent;
     /* EventStreamMarshallerGenerator.kt:135 */
     fn marshall(&self, input: Self::Input) -> std::result::Result<::aws_smithy_types::event_stream::Message, ::aws_smithy_eventstream::error::Error> {
         /* EventStreamMarshallerGenerator.kt:139 */
         let mut headers = Vec::new();
         /* EventStreamMarshallerGenerator.kt:322 */
         headers.push(::aws_smithy_types::event_stream::Header::new(
             ":message-type",
             ::aws_smithy_types::event_stream::HeaderValue::String("event".into()),
         ));
         /* EventStreamMarshallerGenerator.kt:141 */
         let payload = match input {
             Self::Input::Event(inner) =>  {
                 headers.push(::aws_smithy_types::event_stream::Header::new(":event-type", ::aws_smithy_types::event_stream::HeaderValue::String("event".into())));
                 headers.push(::aws_smithy_types::event_stream::Header::new(":content-type", ::aws_smithy_types::event_stream::HeaderValue::String("application/json".into())));
                 if let Some(inner_payload) = inner.payload {
                     crate::protocol_serde::shape_capturing_event::ser_payload_payload(&inner_payload)
             /* EventStreamMarshallerGenerator.kt:152 */Self::Input::Event(inner) =>  {
                 /* EventStreamMarshallerGenerator.kt:322 */headers.push(::aws_smithy_types::event_stream::Header::new(":event-type", ::aws_smithy_types::event_stream::HeaderValue::String("event".into())));
                 /* EventStreamMarshallerGenerator.kt:322 */headers.push(::aws_smithy_types::event_stream::Header::new(":content-type", ::aws_smithy_types::event_stream::HeaderValue::String("application/json".into())));
                 /* EventStreamMarshallerGenerator.kt:305 */if let Some(inner_payload) = inner.payload {
                     /* EventStreamMarshallerGenerator.kt:283 */crate::protocol_serde::shape_capturing_event::ser_payload_payload(&inner_payload)
                                                 .map_err(|err| ::aws_smithy_eventstream::error::Error::marshalling(format!("{}", err)))?
--
+                }
                  else  {
                     unimplemented!("TODO(EventStream): Figure out what to do when there's no payload")
--
+                }
--
+            }
             Self::Input::Unknown => return Err(
                 /* EventStreamMarshallerGenerator.kt:305 */}
                 /* EventStreamMarshallerGenerator.kt:309 */ else  {
                     /* EventStreamMarshallerGenerator.kt:292 */unimplemented!("TODO(EventStream): Figure out what to do when there's no payload")
                 /* EventStreamMarshallerGenerator.kt:309 */}
             /* EventStreamMarshallerGenerator.kt:152 */}
             /* EventStreamMarshallerGenerator.kt:159 */Self::Input::Unknown => return Err(
                                             ::aws_smithy_eventstream::error::Error::marshalling("Cannot serialize `AttemptCapturingPokemonEvent::Unknown` for the request. The `Unknown` variant is intended for responses only. It occurs when an outdated client is used after a new enum variant was added on the server side.".to_owned())
-85
+                                        )
--
+        }
--
+        ;
         /* EventStreamMarshallerGenerator.kt:141 */}
         /* EventStreamMarshallerGenerator.kt:169 */;
         Ok(::aws_smithy_types::event_stream::Message::new_from_parts(headers, payload))
         /* EventStreamMarshallerGenerator.kt:135 */
-90
+    }
     /* EventStreamMarshallerGenerator.kt:129 */
-92
+}
-93
 /* EventStreamUnmarshallerGenerator.kt:98 */
 #[non_exhaustive]
 #[derive(Debug)]
 pub struct CapturePokemonEventsUnmarshaller;
-98
 impl CapturePokemonEventsUnmarshaller {
     pub fn new() -> Self {
         CapturePokemonEventsUnmarshaller
-102
+    }
-103
+}
 /* EventStreamUnmarshallerGenerator.kt:112 */
 impl ::aws_smithy_eventstream::frame::UnmarshallMessage for CapturePokemonEventsUnmarshaller {
     /* EventStreamUnmarshallerGenerator.kt:116 */
     type Output = crate::types::CapturePokemonEvents;
     /* EventStreamUnmarshallerGenerator.kt:117 */
     type Error = crate::types::error::CapturePokemonEventsError;
     /* EventStreamUnmarshallerGenerator.kt:119 */
     fn unmarshall(
         &self,
         message: &::aws_smithy_types::event_stream::Message,
     ) -> std::result::Result<::aws_smithy_eventstream::frame::UnmarshalledMessage<Self::Output, Self::Error>, ::aws_smithy_eventstream::error::Error>
-115
+    {
         /* EventStreamUnmarshallerGenerator.kt:128 */
         let response_headers = ::aws_smithy_eventstream::smithy::parse_response_headers(message)?;
         /* EventStreamUnmarshallerGenerator.kt:129 */
         match response_headers.message_type.as_str() {
             /* EventStreamUnmarshallerGenerator.kt:130 */
             "event" => {
                 /* EventStreamUnmarshallerGenerator.kt:155 */
                 match response_headers.smithy_type.as_str() {
                     /* EventStreamUnmarshallerGenerator.kt:158 */
                     "event" => {
                         /* EventStreamUnmarshallerGenerator.kt:221 */
                         let mut builder = crate::types::builders::CaptureEventBuilder::default();
                         /* EventStreamUnmarshallerGenerator.kt:275 */
                         let content_type = response_headers.content_type().unwrap_or_default();
                         if content_type != "application/octet-stream" {
                             return Err(::aws_smithy_eventstream::error::Error::unmarshalling(format!(
                                 "expected :content-type to be 'application/octet-stream', but was '{}'",
                                 content_type
                             )));
-135
+                        }
                         builder = builder.set_pokedex_update(Some(::aws_smithy_types::Blob::new(message.payload().as_ref())));
                         /* EventStreamUnmarshallerGenerator.kt:288 */
                         builder = builder.set_pokedex_update(
                             /* EventStreamUnmarshallerGenerator.kt:289 */
                             Some(
                                 /* EventStreamUnmarshallerGenerator.kt:292 */
                                 ::aws_smithy_types::Blob::new(message.payload().as_ref()), /* EventStreamUnmarshallerGenerator.kt:289 */
                             ), /* EventStreamUnmarshallerGenerator.kt:288 */
                         );
                         /* EventStreamUnmarshallerGenerator.kt:228 */
                         for header in message.headers() {
                             /* EventStreamUnmarshallerGenerator.kt:229 */
                             match header.name().as_str() {
                                 /* EventStreamUnmarshallerGenerator.kt:231 */
                                 "name" => {
                                     builder = builder.set_name(Some(::aws_smithy_eventstream::smithy::expect_string(header)?));
                                     /* EventStreamUnmarshallerGenerator.kt:255 */
                                     builder = builder.set_name(
                                         /* EventStreamUnmarshallerGenerator.kt:256 */
                                         Some(
                                             /* EventStreamUnmarshallerGenerator.kt:264 */
                                             ::aws_smithy_eventstream::smithy::expect_string(header)?, /* EventStreamUnmarshallerGenerator.kt:256 */
                                         ), /* EventStreamUnmarshallerGenerator.kt:255 */
                                     );
                                     /* EventStreamUnmarshallerGenerator.kt:231 */
-159
+                                }
                                 /* EventStreamUnmarshallerGenerator.kt:231 */
                                 "captured" => {
                                     builder = builder.set_captured(Some(::aws_smithy_eventstream::smithy::expect_bool(header)?));
                                     /* EventStreamUnmarshallerGenerator.kt:255 */
                                     builder = builder.set_captured(
                                         /* EventStreamUnmarshallerGenerator.kt:256 */
                                         Some(
                                             /* EventStreamUnmarshallerGenerator.kt:258 */
                                             ::aws_smithy_eventstream::smithy::expect_bool(header)?, /* EventStreamUnmarshallerGenerator.kt:256 */
                                         ), /* EventStreamUnmarshallerGenerator.kt:255 */
                                     );
                                     /* EventStreamUnmarshallerGenerator.kt:231 */
-171
+                                }
                                 /* EventStreamUnmarshallerGenerator.kt:231 */
                                 "shiny" => {
                                     builder = builder.set_shiny(Some(::aws_smithy_eventstream::smithy::expect_bool(header)?));
                                     /* EventStreamUnmarshallerGenerator.kt:255 */
                                     builder = builder.set_shiny(
                                         /* EventStreamUnmarshallerGenerator.kt:256 */
                                         Some(
                                             /* EventStreamUnmarshallerGenerator.kt:258 */
                                             ::aws_smithy_eventstream::smithy::expect_bool(header)?, /* EventStreamUnmarshallerGenerator.kt:256 */
                                         ), /* EventStreamUnmarshallerGenerator.kt:255 */
                                     );
                                     /* EventStreamUnmarshallerGenerator.kt:231 */
-183
+                                }
                                 // Event stream protocol headers start with ':'
                                 /* EventStreamUnmarshallerGenerator.kt:235 */// Event stream protocol headers start with ':'
                                 /* EventStreamUnmarshallerGenerator.kt:236 */
                                 name => {
                                     if !name.starts_with(':') {
                                         /* EventStreamUnmarshallerGenerator.kt:237 */
                                         ::tracing::trace!("Unrecognized event stream message header: {}", name);
                                         /* EventStreamUnmarshallerGenerator.kt:236 */
-191
+                                    }
                                 } /* EventStreamUnmarshallerGenerator.kt:229 */
-193
+                            }
                             /* EventStreamUnmarshallerGenerator.kt:228 */
-195
+                        }
--
+                        }
                         /* EventStreamUnmarshallerGenerator.kt:245 */
                         Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(
                             crate::types::CapturePokemonEvents::Event(builder.build()),
                         ))
                         /* EventStreamUnmarshallerGenerator.kt:158 */
-201
+                    }
                     _unknown_variant => Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(
                     /* EventStreamUnmarshallerGenerator.kt:162 */
                     _unknown_variant => {
                         /* EventStreamUnmarshallerGenerator.kt:165 */
                         Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Event(
                             crate::types::CapturePokemonEvents::Unknown,
                     )),
                         ))
                         /* EventStreamUnmarshallerGenerator.kt:162 */
                     } /* EventStreamUnmarshallerGenerator.kt:155 */
-210
+                }
                 /* EventStreamUnmarshallerGenerator.kt:130 */
-212
+            }
             /* EventStreamUnmarshallerGenerator.kt:133 */
             "exception" => {
                 /* EventStreamUnmarshallerGenerator.kt:332 */
                 let generic = match crate::protocol_serde::parse_event_stream_error_metadata(message.payload()) {
                     Ok(builder) => builder.build(),
                     Err(err) => {
                         return Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                             crate::types::error::CapturePokemonEventsError::unhandled(err),
                         ))
-222
+                    }
                 };
                 /* EventStreamUnmarshallerGenerator.kt:356 */
                 match response_headers.smithy_type.as_str() {
                     /* EventStreamUnmarshallerGenerator.kt:358 */
                     "invalid_pokeball" => {
                         /* EventStreamUnmarshallerGenerator.kt:367 */
                         let mut builder = crate::types::error::builders::InvalidPokeballErrorBuilder::default();
                         /* EventStreamUnmarshallerGenerator.kt:368 */
                         builder =
                             crate::protocol_serde::shape_invalid_pokeball_error::de_invalid_pokeball_error_json_err(&message.payload()[..], builder)
                                 .map_err(|err| {
                                     ::aws_smithy_eventstream::error::Error::unmarshalling(format!("failed to unmarshall invalid_pokeball: {}", err))
                                 })?;
                         builder.set_meta(Some(generic));
                         return Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                             crate::types::error::CapturePokemonEventsError::InvalidPokeballError(
                                 crate::serde_util::invalid_pokeball_error_correct_errors(builder)
                                     .build()
                                     .map_err(|err| ::aws_smithy_eventstream::error::Error::unmarshalling(format!("{}", err)))?,
                             ),
                         ));
                         /* EventStreamUnmarshallerGenerator.kt:358 */
-245
+                    }
                     /* EventStreamUnmarshallerGenerator.kt:358 */
                     "throttlingError" => {
                         /* EventStreamUnmarshallerGenerator.kt:367 */
                         let mut builder = crate::types::error::builders::ThrottlingErrorBuilder::default();
                         /* EventStreamUnmarshallerGenerator.kt:368 */
                         builder = crate::protocol_serde::shape_throttling_error::de_throttling_error_json_err(&message.payload()[..], builder)
                             .map_err(|err| {
                                 ::aws_smithy_eventstream::error::Error::unmarshalling(format!("failed to unmarshall throttlingError: {}", err))
                             })?;
                         builder.set_meta(Some(generic));
                         return Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                             crate::types::error::CapturePokemonEventsError::ThrottlingError(builder.build()),
                         ));
                         /* EventStreamUnmarshallerGenerator.kt:358 */
-260
+                    }
                     _ => {}
                     /* EventStreamUnmarshallerGenerator.kt:434 */ _ => {} /* EventStreamUnmarshallerGenerator.kt:435 */
-262
+                }
                 /* EventStreamUnmarshallerGenerator.kt:440 */
                 Ok(::aws_smithy_eventstream::frame::UnmarshalledMessage::Error(
                     crate::types::error::CapturePokemonEventsError::generic(generic),
                 ))
                 /* EventStreamUnmarshallerGenerator.kt:133 */
-268
+            }
             /* EventStreamUnmarshallerGenerator.kt:136 */
             value => {
                 /* EventStreamUnmarshallerGenerator.kt:137 */
                 return Err(::aws_smithy_eventstream::error::Error::unmarshalling(format!(
                     "unrecognized :message-type: {}",
                     value
                 )));
                 /* EventStreamUnmarshallerGenerator.kt:136 */
             } /* EventStreamUnmarshallerGenerator.kt:129 */
-278
+        }
         /* EventStreamUnmarshallerGenerator.kt:119 */
-280
+    }
--
+    }
     /* EventStreamUnmarshallerGenerator.kt:112 */
-282
+}

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

@@ -18,18 +136,148 @@

↥ Expand context

 #![forbid(unsafe_code)]
 #![warn(missing_docs)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 //! The Pokémon Service allows you to retrieve information about Pokémon species.
 //!
 //! # Crate Organization
 //!
 //! The entry point for most customers will be [`Client`], which exposes one method for each API
 //! offered by Pokémon 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 Pokémon Service.
 /// /* FluentClientDocs.kt:24 */Client for calling Pokémon 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 = pokemon_service_client::Config::builder()
 ///     .endpoint_url("http://localhost:1234")
 ///     .build();
 /// let client = pokemon_service_client::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.
 /// # Using the `Client`
 /// /* FluentClientDocs.kt:79 */# Using the `Client`
 ///
 /// A client has a function for every operation that can be performed by the service.
 /// For example, the [`CapturePokemon`](crate::operation::capture_pokemon) operation has
 /// a [`Client::capture_pokemon`], function which returns a builder for that operation.
 /// The fluent builder ultimately has a `send()` function that returns an async future that
 /// returns a result, as illustrated below:
 ///
 /// ```rust,ignore
 /// let result = client.capture_pokemon()
 ///     .region("example")
 ///     .send()
 ///     .await;
 /// ```
 ///
 /// The underlying HTTP requests that get made by this can be modified with the `customize_operation`
 /// function on the fluent builder. See the [`customize`](crate::client::customize) module for more
 /// information.
 pub mod client;
-102
 /// Configuration for Pokémon Service.
 /// /* ClientRustModule.kt:121 */Configuration for Pokémon Service.
 pub mod config;
-105
 /// Common errors and error handling utilities.
 /// /* ClientRustModule.kt:121 */Common errors and error handling utilities.
 pub mod error;
-108
 /* RustModule.kt:172 */
 mod error_meta;
-111
 /// Information about this crate.
 /// /* ClientRustModule.kt:121 */Information about this crate.
 pub mod meta;
-114
 /// 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;
-117
 /// Data structures used by operation inputs/outputs.
 /// /* ClientRustModule.kt:121 */Data structures used by operation inputs/outputs.
 pub mod types;
-120
 /* RustModule.kt:172 */
 mod auth_plugin;
-123
 /* RustModule.kt:172 */
 mod event_receiver;
-126
 /* RustModule.kt:172 */
 mod event_stream_serde;
-129
 /// All operations that this crate can perform.
 /// /* ClientRustModule.kt:121 */All operations that this crate can perform.
 pub mod operation;
-132
 pub(crate) mod protocol_serde;
-134
 /* RustModule.kt:172 */
 mod sdk_feature_tracker;
-137
 /* RustModule.kt:172 */
 mod serialization_settings;
-140
 /* RustModule.kt:172 */
 mod serde_util;
-143
 /* RustModule.kt:172 */
 mod json_errors;
-146
 /* FluentClientDecorator.kt:76 */
 pub use client::Client;

tmp-codegen-diff/codegen-client-test/pokemon-service-client/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/pokemon-service-client/rust-client-codegen/src/operation.rs

@@ -1,1 +22,22 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
--
 /// Types for the `CapturePokemon` operation.
 /* CodegenDelegator.kt:51 */
 /// /* CodegenDelegator.kt:51 */Types for the `CapturePokemon` operation.
 pub mod capture_pokemon;
-5
 /// Types for the `CheckHealth` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `CheckHealth` operation.
 pub mod check_health;
-8
 /// Types for the `DoNothing` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `DoNothing` operation.
 pub mod do_nothing;
-11
 /// Types for the `GetPokemonSpecies` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `GetPokemonSpecies` operation.
 pub mod get_pokemon_species;
-14
 /// Types for the `GetServerStatistics` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `GetServerStatistics` operation.
 pub mod get_server_statistics;
-17
 /// Types for the `GetStorage` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `GetStorage` operation.
 pub mod get_storage;
-20
 /// Types for the `StreamPokemonRadio` operation.
 /// /* CodegenDelegator.kt:51 */Types for the `StreamPokemonRadio` operation.
 pub mod stream_pokemon_radio;

tmp-codegen-diff/codegen-client-test/pokemon-service-client/rust-client-codegen/src/operation/capture_pokemon.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 `CapturePokemon`.
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* OperationGenerator.kt:84 */
 pub struct CapturePokemon;
 /* OperationGenerator.kt:85 */
 impl CapturePokemon {
     /// Creates a new `CapturePokemon`
     /// /* OperationGenerator.kt:86 */Creates a new `CapturePokemon`
     /* 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::capture_pokemon::CapturePokemonInput,
     ) -> ::std::result::Result<
         crate::operation::capture_pokemon::CapturePokemonOutput,
         ::aws_smithy_runtime_api::client::result::SdkError<
             crate::operation::capture_pokemon::CapturePokemonError,
             ::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::capture_pokemon::CapturePokemonError>()
                     .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::capture_pokemon::CapturePokemonOutput>()
                 .expect("correct output type"),
-47
+        )
-48
+    }
-49

@@ -57,66 +190,203 @@

↥ Expand context

             .instrument(::tracing::debug_span!(
                 "PokemonService.CapturePokemon",
                 "rpc.service" = "PokemonService",
                 "rpc.method" = "CapturePokemon",
                 "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
             ))
             .await
-73
+    }
-74
     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);
-87
+            }
             runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
                 config_override,
                 client_config.config.clone(),
                 &client_config.runtime_components,
             ));
-93
+        }
         runtime_plugins
-95
+    }
     /* OperationGenerator.kt:85 */
-97
+}
 /* OperationRuntimePluginGenerator.kt:55 */
 impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for CapturePokemon {
     fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         let mut cfg = ::aws_smithy_types::config_bag::Layer::new("CapturePokemon");
-102
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
             CapturePokemonRequestSerializer,
         ));
         cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
             CapturePokemonResponseDeserializer,
         ));
-109
         cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
             ::aws_smithy_runtime_api::client::auth::static_resolver::StaticAuthSchemeOptionResolverParams::new(),
         ));
-113
         cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
             "CapturePokemon",
             "PokemonService",
         ));
-118
         ::std::option::Option::Some(cfg.freeze())
-120
+    }
-121
     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("CapturePokemon")
             .with_interceptor(CapturePokemonEndpointParamsInterceptor)
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
                 crate::operation::capture_pokemon::CapturePokemonError,
             >::new())
             .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
                 crate::operation::capture_pokemon::CapturePokemonError,
             >::new());
-135
         ::std::borrow::Cow::Owned(rcb)
-137
+    }
-138
+}
-139
 /* ResponseDeserializerGenerator.kt:64 */
 #[derive(Debug)]
 struct CapturePokemonResponseDeserializer;
 impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for CapturePokemonResponseDeserializer {
     fn deserialize_streaming(
         &self,
         response: &mut ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::std::option::Option<::aws_smithy_runtime_api::client::interceptors::context::OutputOrError> {
         #[allow(unused_mut)]
         let mut force_error = false;
-150
         // If this is an error, defer to the non-streaming parser
         if (!response.status().is_success() && response.status().as_u16() != 200) || force_error {
             return ::std::option::Option::None;
-154
+        }
         ::std::option::Option::Some(crate::protocol_serde::type_erase_result(
             crate::protocol_serde::shape_capture_pokemon::de_capture_pokemon_http_response(response),
         ))
-158
+    }
-159
     fn deserialize_nonstreaming(
         &self,
         response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
     ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         // For streaming operations, we only hit this case if its an error
         let body = response.body().bytes().expect("body loaded");
         crate::protocol_serde::type_erase_result(crate::protocol_serde::shape_capture_pokemon::de_capture_pokemon_http_error(
             response.status().as_u16(),
             response.headers(),
             body,
         ))
-171
+    }
-172
+}
 /* RequestSerializerGenerator.kt:67 */
 #[derive(Debug)]
 struct CapturePokemonRequestSerializer;
 impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for CapturePokemonRequestSerializer {
     #[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

↧ Expand context

             .downcast::<crate::operation::capture_pokemon::CapturePokemonInput>()
             .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::capture_pokemon::CapturePokemonInput,
                 output: &mut ::std::string::String,
             ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
                 use ::std::fmt::Write as _;
                 let input_1 = &_input.region;
                 let input_1 = input_1
                     .as_ref()
                     .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("region", "cannot be empty or unset"))?;
                 let region = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
                 if region.is_empty() {
                     return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
                         "region",

@@ -198,211 +410,603 @@

↥ Expand context

             fn update_http_builder(
                 input: &crate::operation::capture_pokemon::CapturePokemonInput,
                 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))
-218
+            }
             let mut builder = update_http_builder(&input, ::http::request::Builder::new())?;
             builder = _header_serialization_settings.set_default_header(builder, ::http::header::CONTENT_TYPE, "application/vnd.amazon.eventstream");
             builder
         };
         let body = ::aws_smithy_types::body::SdkBody::from({
             let error_marshaller = crate::event_stream_serde::AttemptCapturingPokemonEventErrorMarshaller::new();
             let marshaller = crate::event_stream_serde::AttemptCapturingPokemonEventMarshaller::new();
             let (signer, signer_sender) = ::aws_smithy_eventstream::frame::DeferredSigner::new();
             _cfg.interceptor_state().store_put(signer_sender);
             ::aws_smithy_types::body::SdkBody::from_body_0_4(::hyper::Body::wrap_stream(input.events.into_body_stream(
                 marshaller,
                 error_marshaller,

                 signer,
             )))
         });
         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);
-237
+        }
         ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
-239
+    }
-240
+}
 /* EndpointParamsInterceptorGenerator.kt:86 */
 #[derive(Debug)]
 struct CapturePokemonEndpointParamsInterceptor;
-244
 impl ::aws_smithy_runtime_api::client::interceptors::Intercept for CapturePokemonEndpointParamsInterceptor {
     fn name(&self) -> &'static str {
         "CapturePokemonEndpointParamsInterceptor"
-248
+    }
-249
     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::<CapturePokemonInput>()
             .ok_or("failed to downcast to CapturePokemonInput")?;
-264
         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(())
-271
+    }
-272
+}
-273
 // The get_* functions below are generated from JMESPath expressions in the
 // operationContextParams trait. They target the operation's input shape.
-276
 /* OperationErrorGenerator.kt:79 */
 /// Error type for the `CapturePokemonError` operation.
 /* RustType.kt:516 */
 #[non_exhaustive]
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum CapturePokemonError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 pub /* OperationErrorGenerator.kt:81 */ enum CapturePokemonError {
     /// /* OperationErrorGenerator.kt:83 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /* OperationErrorGenerator.kt:86 */
     ValidationError(crate::types::error::ValidationError),
     /* OperationErrorGenerator.kt:83 */
     #[allow(missing_docs)] // documentation missing in model
     /* OperationErrorGenerator.kt:86 */
     MasterBallUnsuccessful(crate::types::error::MasterBallUnsuccessful),
     /* OperationErrorGenerator.kt:83 */
     #[allow(missing_docs)] // documentation missing in model
     /* OperationErrorGenerator.kt:86 */
     InvalidPokeballError(crate::types::error::InvalidPokeballError),
     /* OperationErrorGenerator.kt:83 */
     #[allow(missing_docs)] // documentation missing in model
     /* OperationErrorGenerator.kt:86 */
     ThrottlingError(crate::types::error::ThrottlingError),
     /* OperationErrorGenerator.kt:83 */
     #[allow(missing_docs)] // documentation missing in model
     /* OperationErrorGenerator.kt:86 */
     UnsupportedRegionError(crate::types::error::UnsupportedRegionError),
     /* 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()`:
-307
+     \
     &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
-309
+     \
     See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-CapturePokemonError) for what information is available for the error.")]
     Unhandled(crate::error::sealed_unhandled::Unhandled),
     /* OperationErrorGenerator.kt:81 */
-313
+}
 /* OperationErrorGenerator.kt:218 */
 impl CapturePokemonError {
     /* OperationErrorGenerator.kt:219 */
     /// Creates the `CapturePokemonError::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(),
         })
-325
+    }
-326
     /// Creates the `CapturePokemonError::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,
         })
-333
+    }
     ///
     /// /* 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::ValidationError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             /* OperationErrorGenerator.kt:246 */ Self::ValidationError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             /* OperationErrorGenerator.kt:246 */
             Self::MasterBallUnsuccessful(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             /* OperationErrorGenerator.kt:246 */
             Self::InvalidPokeballError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::ThrottlingError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             /* OperationErrorGenerator.kt:246 */ Self::ThrottlingError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             /* OperationErrorGenerator.kt:246 */
             Self::UnsupportedRegionError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
             Self::Unhandled(e) => &e.meta,
             /* OperationErrorGenerator.kt:251 */ Self::Unhandled(e) => &e.meta,
             /* OperationErrorGenerator.kt:243 */
-352
+        }
         /* OperationErrorGenerator.kt:242 */
-354
+    }
     /* OperationErrorGenerator.kt:257 */
     /// Returns `true` if the error kind is `CapturePokemonError::ValidationError`.
     /* OperationErrorGenerator.kt:258 */
     pub fn is_validation_error(&self) -> bool {
         /* OperationErrorGenerator.kt:259 */
         matches!(self, Self::ValidationError(_))
         /* OperationErrorGenerator.kt:258 */
-362
+    }
     /* OperationErrorGenerator.kt:257 */
     /// Returns `true` if the error kind is `CapturePokemonError::MasterBallUnsuccessful`.
     /* OperationErrorGenerator.kt:258 */
     pub fn is_master_ball_unsuccessful(&self) -> bool {
         /* OperationErrorGenerator.kt:259 */
         matches!(self, Self::MasterBallUnsuccessful(_))
         /* OperationErrorGenerator.kt:258 */
-370
+    }
     /* OperationErrorGenerator.kt:257 */
     /// Returns `true` if the error kind is `CapturePokemonError::InvalidPokeballError`.
     /* OperationErrorGenerator.kt:258 */
     pub fn is_invalid_pokeball_error(&self) -> bool {
         /* OperationErrorGenerator.kt:259 */
         matches!(self, Self::InvalidPokeballError(_))
         /* OperationErrorGenerator.kt:258 */
-378
+    }
     /* OperationErrorGenerator.kt:257 */
     /// Returns `true` if the error kind is `CapturePokemonError::ThrottlingError`.
     /* OperationErrorGenerator.kt:258 */
     pub fn is_throttling_error(&self) -> bool {
         /* OperationErrorGenerator.kt:259 */
         matches!(self, Self::ThrottlingError(_))
         /* OperationErrorGenerator.kt:258 */
-386
+    }
     /* OperationErrorGenerator.kt:257 */
     /// Returns `true` if the error kind is `CapturePokemonError::UnsupportedRegionError`.
     /* OperationErrorGenerator.kt:258 */
     pub fn is_unsupported_region_error(&self) -> bool {
         /* OperationErrorGenerator.kt:259 */
         matches!(self, Self::UnsupportedRegionError(_))
         /* OperationErrorGenerator.kt:258 */
-394
+    }
     /* OperationErrorGenerator.kt:218 */
-396
+}
 /* OperationErrorGenerator.kt:269 */
 impl ::std::error::Error for CapturePokemonError {
     /* OperationErrorGenerator.kt:270 */
     fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* OperationErrorGenerator.kt:318 */
         match self {
             Self::ValidationError(_inner) => ::std::option::Option::Some(_inner),
             Self::MasterBallUnsuccessful(_inner) => ::std::option::Option::Some(_inner),
             Self::InvalidPokeballError(_inner) => ::std::option::Option::Some(_inner),
             Self::ThrottlingError(_inner) => ::std::option::Option::Some(_inner),
             Self::UnsupportedRegionError(_inner) => ::std::option::Option::Some(_inner),
             Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
             /* OperationErrorGenerator.kt:321 */
             Self::ValidationError(_inner) =>
             /* OperationErrorGenerator.kt:283 */
-+
+            {
                 ::std::option::Option::Some(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::MasterBallUnsuccessful(_inner) =>
             /* OperationErrorGenerator.kt:283 */
-+
+            {
                 ::std::option::Option::Some(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::InvalidPokeballError(_inner) =>
             /* OperationErrorGenerator.kt:283 */
-+
+            {
                 ::std::option::Option::Some(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::ThrottlingError(_inner) =>
             /* OperationErrorGenerator.kt:283 */
-+
+            {
                 ::std::option::Option::Some(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::UnsupportedRegionError(_inner) =>
             /* OperationErrorGenerator.kt:283 */
-+
+            {
                 ::std::option::Option::Some(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:326 */
             Self::Unhandled(_inner) => {
                 /* OperationErrorGenerator.kt:279 */
                 ::std::option::Option::Some(&*_inner.source)
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-444
+        }
         /* OperationErrorGenerator.kt:270 */
-446
+    }
     /* OperationErrorGenerator.kt:269 */
-448
+}
 /* OperationErrorGenerator.kt:133 */
 impl ::std::fmt::Display for CapturePokemonError {
     /* OperationErrorGenerator.kt:134 */
     fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         /* OperationErrorGenerator.kt:318 */
         match self {
             Self::ValidationError(_inner) => _inner.fmt(f),
             Self::MasterBallUnsuccessful(_inner) => _inner.fmt(f),
             Self::InvalidPokeballError(_inner) => _inner.fmt(f),
             Self::ThrottlingError(_inner) => _inner.fmt(f),
             Self::UnsupportedRegionError(_inner) => _inner.fmt(f),
             /* OperationErrorGenerator.kt:321 */
             Self::ValidationError(_inner) =>
             /* OperationErrorGenerator.kt:151 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::MasterBallUnsuccessful(_inner) =>
             /* OperationErrorGenerator.kt:151 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::InvalidPokeballError(_inner) =>
             /* OperationErrorGenerator.kt:151 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::ThrottlingError(_inner) =>
             /* OperationErrorGenerator.kt:151 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::UnsupportedRegionError(_inner) =>
             /* OperationErrorGenerator.kt:151 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* 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")
-497
+                }
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-500
+        }
         /* OperationErrorGenerator.kt:134 */
-502
+    }
--
+    }
     /* OperationErrorGenerator.kt:133 */
-504
+}
 /* OperationErrorGenerator.kt:182 */
 impl ::aws_smithy_types::retry::ProvideErrorKind for CapturePokemonError {
     /* OperationErrorGenerator.kt:186 */
     fn code(&self) -> ::std::option::Option<&str> {
         /* OperationErrorGenerator.kt:187 */
         ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
         /* OperationErrorGenerator.kt:186 */
-512
+    }
     /* 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 */
-518
+    }
     /* OperationErrorGenerator.kt:182 */
-520
+}
 /* OperationErrorGenerator.kt:163 */
 impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for CapturePokemonError {
     /* OperationErrorGenerator.kt:164 */
     fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         /* OperationErrorGenerator.kt:318 */
         match self {
             Self::ValidationError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::MasterBallUnsuccessful(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::InvalidPokeballError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::ThrottlingError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::UnsupportedRegionError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
             Self::Unhandled(_inner) => &_inner.meta,
             /* OperationErrorGenerator.kt:321 */
             Self::ValidationError(_inner) =>
             /* OperationErrorGenerator.kt:169 */
-+
+            {
                 ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::MasterBallUnsuccessful(_inner) =>
             /* OperationErrorGenerator.kt:169 */
-+
+            {
                 ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::InvalidPokeballError(_inner) =>
             /* OperationErrorGenerator.kt:169 */
-+
+            {
                 ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::ThrottlingError(_inner) =>
             /* OperationErrorGenerator.kt:169 */
-+
+            {
                 ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:321 */
             Self::UnsupportedRegionError(_inner) =>
             /* OperationErrorGenerator.kt:169 */
-+
+            {
                 ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner)
-+
+            }
-+
+            ,
             /* OperationErrorGenerator.kt:326 */
             Self::Unhandled(_inner) => {
                 /* OperationErrorGenerator.kt:168 */
                 &_inner.meta
                 /* OperationErrorGenerator.kt:326 */
             } /* OperationErrorGenerator.kt:318 */
-568
+        }
         /* OperationErrorGenerator.kt:164 */
-570
+    }
     /* OperationErrorGenerator.kt:163 */
-572
+}
 /* OperationErrorGenerator.kt:109 */
 impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for CapturePokemonError {
     /* 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 */
-586
+    }
     /* OperationErrorGenerator.kt:109 */
-588
+}
-589
 /* CodegenDelegator.kt:255 */
 pub use crate::operation::capture_pokemon::_capture_pokemon_output::CapturePokemonOutput;
-592
 /* CodegenDelegator.kt:255 */
 pub use crate::operation::capture_pokemon::_capture_pokemon_input::CapturePokemonInput;
-595
 /* RustModule.kt:172 */
 mod _capture_pokemon_input;
-598
 /* RustModule.kt:172 */
 mod _capture_pokemon_output;
-601
 /// Builders
 /// /* CodegenDelegator.kt:51 */Builders
 pub mod builders;

 // 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 [`GetStorage`](crate::operation::get_storage::builders::GetStorageFluentBuilder) operation.
     ///
     /// - The fluent builder is configurable:
     ///   - [`user(impl Into<String>)`](crate::operation::get_storage::builders::GetStorageFluentBuilder::user) / [`set_user(Option<String>)`](crate::operation::get_storage::builders::GetStorageFluentBuilder::set_user):<br>required: **true**<br>(undocumented)<br>
     ///   - [`passcode(impl Into<String>)`](crate::operation::get_storage::builders::GetStorageFluentBuilder::passcode) / [`set_passcode(Option<String>)`](crate::operation::get_storage::builders::GetStorageFluentBuilder::set_passcode):<br>required: **true**<br>(undocumented)<br>
     /// - On success, responds with [`GetStorageOutput`](crate::operation::get_storage::GetStorageOutput) with field(s):
     ///   - [`collection(Vec::<String>)`](crate::operation::get_storage::GetStorageOutput::collection): A list of Pokémon species.
     /// - On failure, responds with [`SdkError<GetStorageError>`](crate::operation::get_storage::GetStorageError)
     /* FluentClientGenerator.kt:234 */
     pub fn get_storage(&self) -> crate::operation::get_storage::builders::GetStorageFluentBuilder {
         crate::operation::get_storage::builders::GetStorageFluentBuilder::new(self.handle.clone())
-16
+    }
     /* FluentClientGenerator.kt:187 */
-18
+}

 // 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 [`StreamPokemonRadio`](crate::operation::stream_pokemon_radio::builders::StreamPokemonRadioFluentBuilder) operation.
     ///
     /// - The fluent builder takes no input, just [`send`](crate::operation::stream_pokemon_radio::builders::StreamPokemonRadioFluentBuilder::send) it.
     /// - On success, responds with [`StreamPokemonRadioOutput`](crate::operation::stream_pokemon_radio::StreamPokemonRadioOutput) with field(s):
     ///   - [`data(ByteStream)`](crate::operation::stream_pokemon_radio::StreamPokemonRadioOutput::data): (undocumented)
     /// - On failure, responds with [`SdkError<StreamPokemonRadioError>`](crate::operation::stream_pokemon_radio::StreamPokemonRadioError)
     /* FluentClientGenerator.kt:234 */
     pub fn stream_pokemon_radio(&self) -> crate::operation::stream_pokemon_radio::builders::StreamPokemonRadioFluentBuilder {
         crate::operation::stream_pokemon_radio::builders::StreamPokemonRadioFluentBuilder::new(self.handle.clone())
-14
+    }
     /* FluentClientGenerator.kt:187 */
-16
+}

Client Test

Files changed:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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