aws_sdk_transcribestreaming/
config.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2#![allow(clippy::empty_line_after_doc_comments)]
3/// Configuration for a aws_sdk_transcribestreaming service client.
4/// 
5/// Service configuration allows for customization of endpoints, region, credentials providers,
6/// and retry configuration. Generally, it is constructed automatically for you from a shared
7/// configuration loaded by the `aws-config` crate. For example:
8/// 
9/// ```ignore
10/// // Load a shared config from the environment
11/// let shared_config = aws_config::from_env().load().await;
12/// // The client constructor automatically converts the shared config into the service config
13/// let client = Client::new(&shared_config);
14/// ```
15/// 
16/// The service config can also be constructed manually using its builder.
17/// 
18#[derive(::std::clone::Clone, ::std::fmt::Debug)]
19pub struct Config {
20    // Both `config` and `cloneable` are the same config, but the cloneable one
21                    // is kept around so that it is possible to convert back into a builder. This can be
22                    // optimized in the future.
23                    pub(crate) config: crate::config::FrozenLayer,
24                    cloneable: ::aws_smithy_types::config_bag::CloneableLayer,
25                    pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
26                    pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
27                    pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
28}
29impl Config {
30    /// 
31    /// Constructs a config builder.
32    /// <div class="warning">
33    /// Note that a config created from this builder will not have the same safe defaults as one created by
34    /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
35    /// </div>
36    /// 
37    pub fn builder() -> Builder { Builder::default() }
38    /// Converts this config back into a builder so that it can be tweaked.
39                    pub fn to_builder(&self) -> Builder {
40                        Builder {
41                            config: self.cloneable.clone(),
42                            runtime_components: self.runtime_components.clone(),
43                            runtime_plugins: self.runtime_plugins.clone(),
44                            behavior_version: self.behavior_version,
45                        }
46                    }
47    /// Return a reference to the stalled stream protection configuration contained in this config, if any.
48                            pub fn stalled_stream_protection(&self) -> ::std::option::Option<&crate::config::StalledStreamProtectionConfig> {
49                                self.config.load::<crate::config::StalledStreamProtectionConfig>()
50                            }
51    /// Return the [`SharedHttpClient`](crate::config::SharedHttpClient) to use when making requests, if any.
52                            pub fn http_client(&self) -> Option<crate::config::SharedHttpClient> {
53                                self.runtime_components.http_client()
54                            }
55    /// Return the auth schemes configured on this service config
56                            pub fn auth_schemes(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::auth::SharedAuthScheme> + '_ {
57                                self.runtime_components.auth_schemes()
58                            }
59    
60                            /// Return the auth scheme resolver configured on this service config
61                            pub fn auth_scheme_resolver(&self) -> ::std::option::Option<::aws_smithy_runtime_api::client::auth::SharedAuthSchemeOptionResolver> {
62                                self.runtime_components.auth_scheme_option_resolver()
63                            }
64    /// Returns the configured auth scheme preference
65                            pub fn auth_scheme_preference(&self) -> ::std::option::Option<&::aws_smithy_runtime_api::client::auth::AuthSchemePreference> {
66                                self.config.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>()
67                            }
68    /// Returns the endpoint resolver.
69                            pub fn endpoint_resolver(&self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver {
70                                self.runtime_components.endpoint_resolver().expect("resolver defaulted if not set")
71                            }
72    /// Return a reference to the retry configuration contained in this config, if any.
73                            pub fn retry_config(&self) -> ::std::option::Option<&::aws_smithy_types::retry::RetryConfig> {
74                                self.config.load::<::aws_smithy_types::retry::RetryConfig>()
75                            }
76    
77                            /// Return a cloned shared async sleep implementation from this config, if any.
78                            pub fn sleep_impl(&self) -> ::std::option::Option<crate::config::SharedAsyncSleep> {
79                                self.runtime_components.sleep_impl()
80                            }
81    
82                            /// Return a reference to the timeout configuration contained in this config, if any.
83                            pub fn timeout_config(&self) -> ::std::option::Option<&::aws_smithy_types::timeout::TimeoutConfig> {
84                                self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>()
85                            }
86    
87                            /// Returns a reference to the retry partition contained in this config, if any.
88                            ///
89                            /// WARNING: This method is unstable and may be removed at any time. Do not rely on this
90                            /// method for anything!
91                            pub fn retry_partition(&self) -> ::std::option::Option<&::aws_smithy_runtime::client::retries::RetryPartition> {
92                                self.config.load::<::aws_smithy_runtime::client::retries::RetryPartition>()
93                            }
94    /// Returns the configured identity cache for auth.
95                            pub fn identity_cache(&self) -> ::std::option::Option<crate::config::SharedIdentityCache> {
96                                self.runtime_components.identity_cache()
97                            }
98    /// Returns interceptors currently registered by the user.
99                            pub fn interceptors(&self) -> impl Iterator<Item = crate::config::SharedInterceptor> + '_ {
100                                self.runtime_components.interceptors()
101                            }
102    /// Return time source used for this service.
103    pub fn time_source(&self) -> ::std::option::Option<::aws_smithy_async::time::SharedTimeSource> {
104        self.runtime_components.time_source()
105    }
106    /// Returns retry classifiers currently registered by the user.
107                            pub fn retry_classifiers(&self) -> impl Iterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier> + '_ {
108                                self.runtime_components.retry_classifiers()
109                            }
110    /// Returns the name of the app that is using the client, if it was provided.
111                                ///
112                                /// This _optional_ name is used to identify the application in the user agent that
113                                /// gets sent along with requests.
114                                pub fn app_name(&self) -> ::std::option::Option<&::aws_types::app_name::AppName> {
115                                   self.config.load::<::aws_types::app_name::AppName>()
116                                }
117    /// Returns the invocation ID generator if one was given in config.
118    /// 
119    /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
120    pub fn invocation_id_generator(&self) -> ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator> {
121                                self.config.load::<::aws_runtime::invocation_id::SharedInvocationIdGenerator>().cloned()
122                            }
123    /// Creates a new [service config](crate::Config) from a [shared `config`](::aws_types::sdk_config::SdkConfig).
124                            pub fn new(config: &::aws_types::sdk_config::SdkConfig) -> Self {
125                                Builder::from(config).build()
126                            }
127    /// The signature version 4 service signing name to use in the credential scope when signing requests.
128                                ///
129                                /// The signing service may be overridden by the `Endpoint`, or by specifying a custom
130                                /// [`SigningName`](aws_types::SigningName) during operation construction
131                                pub fn signing_name(&self) -> &'static str {
132                                    "transcribe"
133                                }
134    /// Returns the AWS region, if it was provided.
135                            pub fn region(&self) -> ::std::option::Option<&crate::config::Region> {
136                                self.config.load::<crate::config::Region>()
137                            }
138    /// This function was intended to be removed, and has been broken since release-2023-11-15 as it always returns a `None`. Do not use.
139                            #[deprecated(note = "This function was intended to be removed, and has been broken since release-2023-11-15 as it always returns a `None`. Do not use.")]
140                            pub fn credentials_provider(&self) -> Option<crate::config::SharedCredentialsProvider> {
141                                ::std::option::Option::None
142                            }
143}
144/// Builder for creating a `Config`.
145#[derive(::std::clone::Clone, ::std::fmt::Debug)]
146pub struct Builder {
147    pub(crate) config: ::aws_smithy_types::config_bag::CloneableLayer,
148                    pub(crate) runtime_components: crate::config::RuntimeComponentsBuilder,
149                    pub(crate) runtime_plugins: ::std::vec::Vec<crate::config::SharedRuntimePlugin>,
150                    pub(crate) behavior_version: ::std::option::Option<crate::config::BehaviorVersion>,
151}
152impl ::std::default::Default for Builder {
153    fn default() -> Self {
154                        Self {
155                            config: ::std::default::Default::default(),
156                            runtime_components: crate::config::RuntimeComponentsBuilder::new("service config"),
157                            runtime_plugins: ::std::default::Default::default(),
158                            behavior_version: ::std::default::Default::default(),
159                        }
160                    }
161}
162impl Builder {
163    /// 
164    /// Constructs a config builder.
165    /// <div class="warning">
166    /// Note that a config created from this builder will not have the same safe defaults as one created by
167    /// the <a href="https://crates.io/crates/aws-config" target="_blank">aws-config</a> crate.
168    /// </div>
169    /// 
170    pub fn new() -> Self { Self::default() }
171    /// Constructs a config builder from the given `config_bag`, setting only fields stored in the config bag,
172    /// but not those in runtime components.
173    #[allow(unused)]
174    pub(crate) fn from_config_bag(config_bag: &::aws_smithy_types::config_bag::ConfigBag) -> Self {
175        let mut builder = Self::new();
176        builder.set_stalled_stream_protection(config_bag.load::<crate::config::StalledStreamProtectionConfig>().cloned());
177        builder.set_auth_scheme_preference(config_bag.load::<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>().cloned());
178        builder.set_retry_config(config_bag.load::<::aws_smithy_types::retry::RetryConfig>().cloned());
179        builder.set_timeout_config(config_bag.load::<::aws_smithy_types::timeout::TimeoutConfig>().cloned());
180        builder.set_retry_partition(config_bag.load::<::aws_smithy_runtime::client::retries::RetryPartition>().cloned());
181        builder.set_app_name(config_bag.load::<::aws_types::app_name::AppName>().cloned());
182        builder.set_endpoint_url(config_bag.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()));
183        builder.set_use_dual_stack(config_bag.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0));
184        builder.set_use_fips(config_bag.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0));
185        builder.set_region(config_bag.load::<crate::config::Region>().cloned());
186        builder
187    }
188    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
189                            /// to configure protection for stalled streams.
190                            pub fn stalled_stream_protection(
191                                mut self,
192                                stalled_stream_protection_config: crate::config::StalledStreamProtectionConfig
193                            ) -> Self {
194                                self.set_stalled_stream_protection(::std::option::Option::Some(stalled_stream_protection_config));
195                                self
196                            }
197    /// Set the [`StalledStreamProtectionConfig`](crate::config::StalledStreamProtectionConfig)
198                            /// to configure protection for stalled streams.
199                            pub fn set_stalled_stream_protection(
200                                &mut self,
201                                stalled_stream_protection_config: ::std::option::Option<crate::config::StalledStreamProtectionConfig>
202                            ) -> &mut Self {
203                                self.config.store_or_unset(stalled_stream_protection_config);
204                                self
205                            }
206    /// Sets the HTTP client to use when making requests.
207                            ///
208                            /// # Examples
209                            /// ```no_run
210                            /// # #[cfg(test)]
211                            /// # mod tests {
212                            /// # #[test]
213                            /// # fn example() {
214                            /// use std::time::Duration;
215                            /// use aws_sdk_transcribestreaming::config::Config;
216                            /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
217                            ///
218                            /// let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
219                            ///     .with_webpki_roots()
220                            ///     .https_only()
221                            ///     .enable_http1()
222                            ///     .enable_http2()
223                            ///     .build();
224                            /// let hyper_client = HyperClientBuilder::new().build(https_connector);
225                            ///
226                            /// // This connector can then be given to a generated service Config
227                            /// let config = my_service_client::Config::builder()
228                            ///     .endpoint_url("https://example.com")
229                            ///     .http_client(hyper_client)
230                            ///     .build();
231                            /// let client = my_service_client::Client::from_conf(config);
232                            /// # }
233                            /// # }
234                            /// ```
235                            pub fn http_client(mut self, http_client: impl crate::config::HttpClient + 'static) -> Self {
236                                self.set_http_client(::std::option::Option::Some(crate::config::IntoShared::into_shared(http_client)));
237                                self
238                            }
239    
240                            /// Sets the HTTP client to use when making requests.
241                            ///
242                            /// # Examples
243                            /// ```no_run
244                            /// # #[cfg(test)]
245                            /// # mod tests {
246                            /// # #[test]
247                            /// # fn example() {
248                            /// use std::time::Duration;
249                            /// use aws_sdk_transcribestreaming::config::{Builder, Config};
250                            /// use aws_smithy_runtime::client::http::hyper_014::HyperClientBuilder;
251                            ///
252                            /// fn override_http_client(builder: &mut Builder) {
253                            ///     let https_connector = hyper_rustls::HttpsConnectorBuilder::new()
254                            ///         .with_webpki_roots()
255                            ///         .https_only()
256                            ///         .enable_http1()
257                            ///         .enable_http2()
258                            ///         .build();
259                            ///     let hyper_client = HyperClientBuilder::new().build(https_connector);
260                            ///     builder.set_http_client(Some(hyper_client));
261                            /// }
262                            ///
263                            /// let mut builder = aws_sdk_transcribestreaming::Config::builder();
264                            /// override_http_client(&mut builder);
265                            /// let config = builder.build();
266                            /// # }
267                            /// # }
268                            /// ```
269                            pub fn set_http_client(&mut self, http_client: Option<crate::config::SharedHttpClient>) -> &mut Self {
270                                self.runtime_components.set_http_client(http_client);
271                                self
272                            }
273    /// Adds an auth scheme to the builder
274                            ///
275                            /// If `auth_scheme` has an existing [AuthSchemeId](aws_smithy_runtime_api::client::auth::AuthSchemeId) in the runtime, the current identity
276                            /// resolver and signer for that scheme will be replaced by those from `auth_scheme`.
277                            ///
278                            /// _Important:_ When introducing a custom auth scheme, ensure you override either
279                            /// [`Self::auth_scheme_resolver`] or [`Self::set_auth_scheme_resolver`]
280                            /// so that the custom auth scheme is included in the list of resolved auth scheme options.
281                            /// [The default auth scheme resolver](crate::config::auth::DefaultAuthSchemeResolver) will not recognize your custom auth scheme.
282                            ///
283                            /// # Examples
284                            /// ```no_run
285                            /// # use aws_smithy_runtime_api::{
286                            /// #     box_error::BoxError,
287                            /// #     client::{
288                            /// #         auth::{
289                            /// #             AuthScheme, AuthSchemeEndpointConfig, AuthSchemeId, AuthSchemeOption,
290                            /// #             AuthSchemeOptionsFuture, Sign,
291                            /// #         },
292                            /// #         identity::{Identity, IdentityFuture, ResolveIdentity, SharedIdentityResolver},
293                            /// #         orchestrator::HttpRequest,
294                            /// #         runtime_components::{GetIdentityResolver, RuntimeComponents},
295                            /// #   },
296                            /// #   shared::IntoShared,
297                            /// # };
298                            /// # use aws_smithy_types::config_bag::ConfigBag;
299                            /// // Auth scheme with customer identity resolver and signer
300                            /// #[derive(Debug)]
301                            /// struct CustomAuthScheme {
302                            ///     id: AuthSchemeId,
303                            ///     identity_resolver: SharedIdentityResolver,
304                            ///     signer: CustomSigner,
305                            /// }
306                            /// impl Default for CustomAuthScheme {
307                            ///     fn default() -> Self {
308                            ///         Self {
309                            ///             id: AuthSchemeId::new("custom"),
310                            ///             identity_resolver: CustomIdentityResolver.into_shared(),
311                            ///             signer: CustomSigner,
312                            ///         }
313                            ///     }
314                            /// }
315                            /// impl AuthScheme for CustomAuthScheme {
316                            ///     fn scheme_id(&self) -> AuthSchemeId {
317                            ///         self.id.clone()
318                            ///     }
319                            ///     fn identity_resolver(
320                            ///         &self,
321                            ///         _identity_resolvers: &dyn GetIdentityResolver,
322                            ///     ) -> Option<SharedIdentityResolver> {
323                            ///         Some(self.identity_resolver.clone())
324                            ///     }
325                            ///     fn signer(&self) -> &dyn Sign {
326                            ///         &self.signer
327                            ///     }
328                            /// }
329                            ///
330                            /// #[derive(Debug, Default)]
331                            /// struct CustomSigner;
332                            /// impl Sign for CustomSigner {
333                            ///     fn sign_http_request(
334                            ///         &self,
335                            ///         _request: &mut HttpRequest,
336                            ///         _identity: &Identity,
337                            ///         _auth_scheme_endpoint_config: AuthSchemeEndpointConfig<'_>,
338                            ///         _runtime_components: &RuntimeComponents,
339                            ///         _config_bag: &ConfigBag,
340                            ///     ) -> Result<(), BoxError> {
341                            ///         // --snip--
342                            /// #      todo!()
343                            ///     }
344                            /// }
345                            ///
346                            /// #[derive(Debug)]
347                            /// struct CustomIdentityResolver;
348                            /// impl ResolveIdentity for CustomIdentityResolver {
349                            ///     fn resolve_identity<'a>(
350                            ///         &'a self,
351                            ///         _runtime_components: &'a RuntimeComponents,
352                            ///         _config_bag: &'a ConfigBag,
353                            ///     ) -> IdentityFuture<'a> {
354                            ///         // --snip--
355                            /// #      todo!()
356                            ///     }
357                            /// }
358                            ///
359                            /// // Auth scheme resolver that favors `CustomAuthScheme`
360                            /// #[derive(Debug)]
361                            /// struct CustomAuthSchemeResolver;
362                            /// impl aws_sdk_transcribestreaming::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
363                            ///     fn resolve_auth_scheme<'a>(
364                            ///         &'a self,
365                            ///         _params: &'a aws_sdk_transcribestreaming::config::auth::Params,
366                            ///         _cfg: &'a ConfigBag,
367                            ///         _runtime_components: &'a RuntimeComponents,
368                            ///     ) -> AuthSchemeOptionsFuture<'a> {
369                            ///         AuthSchemeOptionsFuture::ready(Ok(vec![AuthSchemeOption::from(AuthSchemeId::new(
370                            ///             "custom",
371                            ///         ))]))
372                            ///     }
373                            /// }
374                            ///
375                            /// let config = aws_sdk_transcribestreaming::Config::builder()
376                            ///     .push_auth_scheme(CustomAuthScheme::default())
377                            ///     .auth_scheme_resolver(CustomAuthSchemeResolver)
378                            ///     // other configurations
379                            ///     .build();
380                            /// ```
381                            pub fn push_auth_scheme(mut self, auth_scheme: impl ::aws_smithy_runtime_api::client::auth::AuthScheme + 'static) -> Self {
382                                self.runtime_components.push_auth_scheme(auth_scheme);
383                                self
384                            }
385    
386                            /// Set the auth scheme resolver for the builder
387                            ///
388                            /// # Examples
389                            /// ```no_run
390                            /// # use aws_smithy_runtime_api::{
391                            /// #     client::{
392                            /// #         auth::AuthSchemeOptionsFuture,
393                            /// #         runtime_components::RuntimeComponents,
394                            /// #   },
395                            /// # };
396                            /// # use aws_smithy_types::config_bag::ConfigBag;
397                            /// #[derive(Debug)]
398                            /// struct CustomAuthSchemeResolver;
399                            /// impl aws_sdk_transcribestreaming::config::auth::ResolveAuthScheme for CustomAuthSchemeResolver {
400                            ///     fn resolve_auth_scheme<'a>(
401                            ///         &'a self,
402                            ///         _params: &'a aws_sdk_transcribestreaming::config::auth::Params,
403                            ///         _cfg: &'a ConfigBag,
404                            ///         _runtime_components: &'a RuntimeComponents,
405                            ///     ) -> AuthSchemeOptionsFuture<'a> {
406                            ///         // --snip--
407                            /// #      todo!()
408                            ///     }
409                            /// }
410                            ///
411                            /// let config = aws_sdk_transcribestreaming::Config::builder()
412                            ///     .auth_scheme_resolver(CustomAuthSchemeResolver)
413                            ///     // other configurations
414                            ///     .build();
415                            /// ```
416                            pub fn auth_scheme_resolver(mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> Self {
417                                self.set_auth_scheme_resolver(auth_scheme_resolver);
418                                self
419                            }
420    
421                            /// Set the auth scheme resolver for the builder
422                            ///
423                            /// # Examples
424                            /// See an example for [`Self::auth_scheme_resolver`].
425                            pub fn set_auth_scheme_resolver(&mut self, auth_scheme_resolver: impl crate::config::auth::ResolveAuthScheme + 'static) -> &mut Self {
426                                self.runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some(auth_scheme_resolver.into_shared_resolver()));
427                                self
428                            }
429    /// Set the auth scheme preference for an auth scheme resolver
430                            /// (typically the default auth scheme resolver).
431                            ///
432                            /// Each operation has a predefined order of auth schemes, as determined by the service,
433                            /// for auth scheme resolution. By using the auth scheme preference, customers
434                            /// can reorder the schemes resolved by the auth scheme resolver.
435                            ///
436                            /// The preference list is intended as a hint rather than a strict override.
437                            /// Any schemes not present in the originally resolved auth schemes will be ignored.
438                            ///
439                            /// # Examples
440                            ///
441                            /// ```no_run
442                            /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
443                            /// let config = aws_sdk_transcribestreaming::Config::builder()
444                            ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
445                            ///     // ...
446                            ///     .build();
447                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
448                            /// ```
449                        
450                            pub fn auth_scheme_preference(mut self, preference: impl ::std::convert::Into<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>) -> Self {
451                                self.set_auth_scheme_preference(::std::option::Option::Some(preference.into()));
452                                self
453                            }
454    
455                            
456                            /// Set the auth scheme preference for an auth scheme resolver
457                            /// (typically the default auth scheme resolver).
458                            ///
459                            /// Each operation has a predefined order of auth schemes, as determined by the service,
460                            /// for auth scheme resolution. By using the auth scheme preference, customers
461                            /// can reorder the schemes resolved by the auth scheme resolver.
462                            ///
463                            /// The preference list is intended as a hint rather than a strict override.
464                            /// Any schemes not present in the originally resolved auth schemes will be ignored.
465                            ///
466                            /// # Examples
467                            ///
468                            /// ```no_run
469                            /// # use aws_smithy_runtime_api::client::auth::AuthSchemeId;
470                            /// let config = aws_sdk_transcribestreaming::Config::builder()
471                            ///     .auth_scheme_preference([AuthSchemeId::from("scheme1"), AuthSchemeId::from("scheme2")])
472                            ///     // ...
473                            ///     .build();
474                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
475                            /// ```
476                        
477                            pub fn set_auth_scheme_preference(&mut self, preference: ::std::option::Option<::aws_smithy_runtime_api::client::auth::AuthSchemePreference>) -> &mut Self {
478                                self.config.store_or_unset(preference);
479                                self
480                            }
481    /// Sets the endpoint resolver to use when making requests.
482                            ///
483                            ///
484                                /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
485                                /// rules for `aws_sdk_transcribestreaming`.
486                                ///
487                            ///
488                            /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
489                            /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
490                            /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
491                            ///
492                            /// # Examples
493                            /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
494                            /// ```no_run
495                            /// use aws_sdk_transcribestreaming::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
496                            /// #[derive(Debug)]
497                            /// struct StageResolver { stage: String }
498                            /// impl ResolveEndpoint for StageResolver {
499                            ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
500                            ///         let stage = &self.stage;
501                            ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
502                            ///     }
503                            /// }
504                            /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
505                            /// let config = aws_sdk_transcribestreaming::Config::builder().endpoint_resolver(resolver).build();
506                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
507                            /// ```
508                            pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
509                                self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
510                                self
511                            }
512    
513                            /// Sets the endpoint resolver to use when making requests.
514                            ///
515                            ///
516                                /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
517                                /// rules for `aws_sdk_transcribestreaming`.
518                                ///
519    pub fn set_endpoint_resolver(&mut self, endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>) -> &mut Self {
520                                self.runtime_components.set_endpoint_resolver(endpoint_resolver);
521                                self
522                            }
523    /// Set the retry_config for the builder
524                            ///
525                            /// # Examples
526                            /// ```no_run
527                            /// use aws_sdk_transcribestreaming::config::Config;
528                            /// use aws_sdk_transcribestreaming::config::retry::RetryConfig;
529                            ///
530                            /// let retry_config = RetryConfig::standard().with_max_attempts(5);
531                            /// let config = Config::builder().retry_config(retry_config).build();
532                            /// ```
533                            pub fn retry_config(mut self, retry_config: ::aws_smithy_types::retry::RetryConfig) -> Self {
534                                self.set_retry_config(Some(retry_config));
535                                self
536                            }
537    
538                            /// Set the retry_config for the builder
539                            ///
540                            /// # Examples
541                            /// ```no_run
542                            /// use aws_sdk_transcribestreaming::config::{Builder, Config};
543                            /// use aws_sdk_transcribestreaming::config::retry::RetryConfig;
544                            ///
545                            /// fn disable_retries(builder: &mut Builder) {
546                            ///     let retry_config = RetryConfig::standard().with_max_attempts(1);
547                            ///     builder.set_retry_config(Some(retry_config));
548                            /// }
549                            ///
550                            /// let mut builder = Config::builder();
551                            /// disable_retries(&mut builder);
552                            /// let config = builder.build();
553                            /// ```
554    pub fn set_retry_config(&mut self, retry_config: ::std::option::Option<::aws_smithy_types::retry::RetryConfig>) -> &mut Self {
555                                retry_config.map(|r| self.config.store_put(r));
556                                self
557                            }
558    /// Set the sleep_impl for the builder
559                            ///
560                            /// # Examples
561                            ///
562                            /// ```no_run
563                            /// use aws_sdk_transcribestreaming::config::{AsyncSleep, Config, SharedAsyncSleep, Sleep};
564                            ///
565                            /// #[derive(Debug)]
566                            /// pub struct ForeverSleep;
567                            ///
568                            /// impl AsyncSleep for ForeverSleep {
569                            ///     fn sleep(&self, duration: std::time::Duration) -> Sleep {
570                            ///         Sleep::new(std::future::pending())
571                            ///     }
572                            /// }
573                            ///
574                            /// let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
575                            /// let config = Config::builder().sleep_impl(sleep_impl).build();
576                            /// ```
577                            pub fn sleep_impl(mut self, sleep_impl: impl crate::config::AsyncSleep + 'static) -> Self {
578                                self.set_sleep_impl(Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(sleep_impl)));
579                                self
580                            }
581    
582                            /// Set the sleep_impl for the builder
583                            ///
584                            /// # Examples
585                            ///
586                            /// ```no_run
587                            /// use aws_sdk_transcribestreaming::config::{AsyncSleep, Builder, Config, SharedAsyncSleep, Sleep};
588                            ///
589                            /// #[derive(Debug)]
590                            /// pub struct ForeverSleep;
591                            ///
592                            /// impl AsyncSleep for ForeverSleep {
593                            ///     fn sleep(&self, duration: std::time::Duration) -> Sleep {
594                            ///         Sleep::new(std::future::pending())
595                            ///     }
596                            /// }
597                            ///
598                            /// fn set_never_ending_sleep_impl(builder: &mut Builder) {
599                            ///     let sleep_impl = SharedAsyncSleep::new(ForeverSleep);
600                            ///     builder.set_sleep_impl(Some(sleep_impl));
601                            /// }
602                            ///
603                            /// let mut builder = Config::builder();
604                            /// set_never_ending_sleep_impl(&mut builder);
605                            /// let config = builder.build();
606                            /// ```
607    pub fn set_sleep_impl(&mut self, sleep_impl: ::std::option::Option<crate::config::SharedAsyncSleep>) -> &mut Self {
608                                self.runtime_components.set_sleep_impl(sleep_impl);
609                                self
610                            }
611    /// Set the timeout_config for the builder
612                            ///
613                            /// # Examples
614                            ///
615                            /// ```no_run
616                            /// # use std::time::Duration;
617                            /// use aws_sdk_transcribestreaming::config::Config;
618                            /// use aws_sdk_transcribestreaming::config::timeout::TimeoutConfig;
619                            ///
620                            /// let timeout_config = TimeoutConfig::builder()
621                            ///     .operation_attempt_timeout(Duration::from_secs(1))
622                            ///     .build();
623                            /// let config = Config::builder().timeout_config(timeout_config).build();
624                            /// ```
625                            pub fn timeout_config(mut self, timeout_config: ::aws_smithy_types::timeout::TimeoutConfig) -> Self {
626                                self.set_timeout_config(Some(timeout_config));
627                                self
628                            }
629    
630                            /// Set the timeout_config for the builder.
631                            ///
632                            /// Setting this to `None` has no effect if another source of configuration has set timeouts. If you
633                            /// are attempting to disable timeouts, use [`TimeoutConfig::disabled`](::aws_smithy_types::timeout::TimeoutConfig::disabled)
634                            ///
635                            ///
636                            /// # Examples
637                            ///
638                            /// ```no_run
639                            /// # use std::time::Duration;
640                            /// use aws_sdk_transcribestreaming::config::{Builder, Config};
641                            /// use aws_sdk_transcribestreaming::config::timeout::TimeoutConfig;
642                            ///
643                            /// fn set_request_timeout(builder: &mut Builder) {
644                            ///     let timeout_config = TimeoutConfig::builder()
645                            ///         .operation_attempt_timeout(Duration::from_secs(1))
646                            ///         .build();
647                            ///     builder.set_timeout_config(Some(timeout_config));
648                            /// }
649                            ///
650                            /// let mut builder = Config::builder();
651                            /// set_request_timeout(&mut builder);
652                            /// let config = builder.build();
653                            /// ```
654    pub fn set_timeout_config(&mut self, timeout_config: ::std::option::Option<::aws_smithy_types::timeout::TimeoutConfig>) -> &mut Self {
655                                // passing None has no impact.
656                                let Some(mut timeout_config) = timeout_config else {
657                                    return self
658                                };
659    
660                                if let Some(base) = self.config.load::<::aws_smithy_types::timeout::TimeoutConfig>() {
661                                    timeout_config.take_defaults_from(base);
662                                }
663                                self.config.store_put(timeout_config);
664                                self
665                            }
666    /// Set the partition for retry-related state. When clients share a retry partition, they will
667                            /// also share components such as token buckets and client rate limiters.
668                            /// See the [`RetryPartition`](::aws_smithy_runtime::client::retries::RetryPartition) documentation for more details.
669                            ///
670                            /// # Default Behavior
671                            ///
672                            /// When no retry partition is explicitly set, the SDK automatically creates a default retry partition named `transcribestreaming`
673                            /// (or `transcribestreaming-<region>` if a region is configured).
674                            /// All Transcribe Streaming clients without an explicit retry partition will share this default partition.
675                            ///
676                            /// # Notes
677                            ///
678                            /// - This is an advanced setting — most users won't need to modify it.
679                            /// - A configured client rate limiter has no effect unless [`RetryConfig::adaptive`](::aws_smithy_types::retry::RetryConfig::adaptive) is used.
680                            ///
681                            /// # Examples
682                            ///
683                            /// Creating a custom retry partition with a token bucket:
684                            /// ```no_run
685                            /// use aws_sdk_transcribestreaming::config::Config;
686                            /// use aws_sdk_transcribestreaming::config::retry::{RetryPartition, TokenBucket};
687                            ///
688                            /// let token_bucket = TokenBucket::new(10);
689                            /// let config = Config::builder()
690                            ///     .retry_partition(RetryPartition::custom("custom")
691                            ///         .token_bucket(token_bucket)
692                            ///         .build()
693                            ///     )
694                            ///     .build();
695                            /// ```
696                            ///
697                            /// Configuring a client rate limiter with adaptive retry mode:
698                            /// ```no_run
699                            /// use aws_sdk_transcribestreaming::config::Config;
700                            /// use aws_sdk_transcribestreaming::config::retry::{ClientRateLimiter, RetryConfig, RetryPartition};
701                            ///
702                            /// let client_rate_limiter = ClientRateLimiter::new(10.0);
703                            /// let config = Config::builder()
704                            ///     .retry_partition(RetryPartition::custom("custom")
705                            ///         .client_rate_limiter(client_rate_limiter)
706                            ///         .build()
707                            ///     )
708                            ///     .retry_config(RetryConfig::adaptive())
709                            ///     .build();
710                            /// ```
711                            pub fn retry_partition(mut self, retry_partition: ::aws_smithy_runtime::client::retries::RetryPartition) -> Self {
712                                self.set_retry_partition(Some(retry_partition));
713                                self
714                            }
715    /// Like [`Self::retry_partition`], but takes a mutable reference to the builder and an optional `RetryPartition`
716                            pub fn set_retry_partition(&mut self, retry_partition: ::std::option::Option<::aws_smithy_runtime::client::retries::RetryPartition>) -> &mut Self {
717                                retry_partition.map(|r| self.config.store_put(r));
718                                self
719                            }
720    /// Set the identity cache for auth.
721                            ///
722                            /// The identity cache defaults to a lazy caching implementation that will resolve
723                            /// an identity when it is requested, and place it in the cache thereafter. Subsequent
724                            /// requests will take the value from the cache while it is still valid. Once it expires,
725                            /// the next request will result in refreshing the identity.
726                            ///
727                            /// This configuration allows you to disable or change the default caching mechanism.
728                            /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
729                            /// trait and pass that implementation into this function.
730                            ///
731                            /// # Examples
732                            ///
733                            /// Disabling identity caching:
734                            /// ```no_run
735                            /// use aws_sdk_transcribestreaming::config::IdentityCache;
736                            ///
737                            /// let config = aws_sdk_transcribestreaming::Config::builder()
738                            ///     .identity_cache(IdentityCache::no_cache())
739                            ///     // ...
740                            ///     .build();
741                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
742                            /// ```
743                            ///
744                            /// Customizing lazy caching:
745                            /// ```no_run
746                            /// use aws_sdk_transcribestreaming::config::IdentityCache;
747                            /// use std::time::Duration;
748                            ///
749                            /// let config = aws_sdk_transcribestreaming::Config::builder()
750                            ///     .identity_cache(
751                            ///         IdentityCache::lazy()
752                            ///             // change the load timeout to 10 seconds
753                            ///             .load_timeout(Duration::from_secs(10))
754                            ///             .build()
755                            ///     )
756                            ///     // ...
757                            ///     .build();
758                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
759                            /// ```
760                        ///
761                            pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
762                                self.set_identity_cache(identity_cache);
763                                self
764                            }
765    
766                            
767                            /// Set the identity cache for auth.
768                            ///
769                            /// The identity cache defaults to a lazy caching implementation that will resolve
770                            /// an identity when it is requested, and place it in the cache thereafter. Subsequent
771                            /// requests will take the value from the cache while it is still valid. Once it expires,
772                            /// the next request will result in refreshing the identity.
773                            ///
774                            /// This configuration allows you to disable or change the default caching mechanism.
775                            /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
776                            /// trait and pass that implementation into this function.
777                            ///
778                            /// # Examples
779                            ///
780                            /// Disabling identity caching:
781                            /// ```no_run
782                            /// use aws_sdk_transcribestreaming::config::IdentityCache;
783                            ///
784                            /// let config = aws_sdk_transcribestreaming::Config::builder()
785                            ///     .identity_cache(IdentityCache::no_cache())
786                            ///     // ...
787                            ///     .build();
788                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
789                            /// ```
790                            ///
791                            /// Customizing lazy caching:
792                            /// ```no_run
793                            /// use aws_sdk_transcribestreaming::config::IdentityCache;
794                            /// use std::time::Duration;
795                            ///
796                            /// let config = aws_sdk_transcribestreaming::Config::builder()
797                            ///     .identity_cache(
798                            ///         IdentityCache::lazy()
799                            ///             // change the load timeout to 10 seconds
800                            ///             .load_timeout(Duration::from_secs(10))
801                            ///             .build()
802                            ///     )
803                            ///     // ...
804                            ///     .build();
805                            /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
806                            /// ```
807                        ///
808                            pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
809                                self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
810                                self
811                            }
812    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
813                            ///
814                            /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
815                            /// The SDK provides a default set of interceptors. An interceptor configured by this method
816                            /// will run after those default interceptors.
817                            ///
818                            /// # Examples
819                            /// ```no_run
820                            /// # fn example() {
821                            /// use aws_smithy_runtime_api::box_error::BoxError;
822                            /// use aws_smithy_runtime_api::client::interceptors::context::BeforeTransmitInterceptorContextMut;
823                            /// use aws_smithy_runtime_api::client::interceptors::Intercept;
824                            /// use aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
825                            /// use aws_smithy_types::config_bag::ConfigBag;
826                            /// use aws_sdk_transcribestreaming::config::Config;
827                            /// use ::http::uri::Uri;
828                            ///
829                            /// fn base_url() -> String {
830                            ///     // ...
831                            ///     # String::new()
832                            /// }
833                            ///
834                            /// #[derive(Debug)]
835                            /// pub struct UriModifierInterceptor;
836                            /// impl Intercept for UriModifierInterceptor {
837                            ///     fn name(&self) -> &'static str {
838                            ///         "UriModifierInterceptor"
839                            ///     }
840                            ///     fn modify_before_signing(
841                            ///         &self,
842                            ///         context: &mut BeforeTransmitInterceptorContextMut<'_>,
843                            ///         _runtime_components: &RuntimeComponents,
844                            ///         _cfg: &mut ConfigBag,
845                            ///     ) -> Result<(), BoxError> {
846                            ///         let request = context.request_mut();
847                            ///         let uri = format!("{}{}", base_url(), request.uri());
848                            ///         *request.uri_mut() = uri.parse::<Uri>()?.into();
849                            ///
850                            ///         Ok(())
851                            ///     }
852                            /// }
853                            ///
854                            /// let config = Config::builder()
855                            ///     .interceptor(UriModifierInterceptor)
856                            ///     .build();
857                            /// # }
858                            /// ```
859                            pub fn interceptor(mut self, interceptor: impl crate::config::Intercept + 'static) -> Self {
860                                self.push_interceptor(crate::config::SharedInterceptor::new(interceptor));
861                                self
862                            }
863    
864                            /// Like [`Self::interceptor`], but takes a [`SharedInterceptor`](crate::config::SharedInterceptor).
865                            pub fn push_interceptor(&mut self, interceptor: crate::config::SharedInterceptor) -> &mut Self {
866                                self.runtime_components.push_interceptor(interceptor);
867                                self
868                            }
869    
870                            /// Set [`SharedInterceptor`](crate::config::SharedInterceptor)s for the builder.
871                            pub fn set_interceptors(&mut self, interceptors: impl IntoIterator<Item = crate::config::SharedInterceptor>) -> &mut Self {
872                                self.runtime_components.set_interceptors(interceptors.into_iter());
873                                self
874                            }
875    /// Sets the time source used for this service
876                            pub fn time_source(
877                                mut self,
878                                time_source: impl ::aws_smithy_async::time::TimeSource + 'static,
879                            ) -> Self {
880                                self.set_time_source(::std::option::Option::Some(::aws_smithy_runtime_api::shared::IntoShared::into_shared(time_source)));
881                                self
882                            }
883    /// Sets the time source used for this service
884                            pub fn set_time_source(
885                                &mut self,
886                                time_source: ::std::option::Option<::aws_smithy_async::time::SharedTimeSource>,
887                            ) -> &mut Self {
888                                self.runtime_components.set_time_source(time_source);
889                                self
890                            }
891    /// Add type implementing [`ClassifyRetry`](::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry) that will be used by the
892                            /// [`RetryStrategy`](::aws_smithy_runtime_api::client::retries::RetryStrategy) to determine what responses should be retried.
893                            ///
894                            /// A retry classifier configured by this method will run according to its [priority](::aws_smithy_runtime_api::client::retries::classifiers::RetryClassifierPriority).
895                            ///
896                            /// # Examples
897                            /// ```no_run
898                            /// # fn example() {
899                            /// use aws_smithy_runtime_api::client::interceptors::context::InterceptorContext;
900                            /// use aws_smithy_runtime_api::client::orchestrator::OrchestratorError;
901                            /// use aws_smithy_runtime_api::client::retries::classifiers::{
902                            ///     ClassifyRetry, RetryAction, RetryClassifierPriority,
903                            /// };
904                            /// use aws_smithy_types::error::metadata::ProvideErrorMetadata;
905                            /// use aws_smithy_types::retry::ErrorKind;
906                            /// use std::error::Error as StdError;
907                            /// use std::marker::PhantomData;
908                            /// use std::fmt;
909                            /// use aws_sdk_transcribestreaming::config::Config;
910                            /// # #[derive(Debug)]
911                            /// # struct SomeOperationError {}
912                            /// # impl StdError for SomeOperationError {}
913                            /// # impl fmt::Display for SomeOperationError {
914                            /// #    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { todo!() }
915                            /// # }
916                            /// # impl ProvideErrorMetadata for SomeOperationError {
917                            /// #    fn meta(&self) -> &aws_sdk_transcribestreaming::error::ErrorMetadata { todo!() }
918                            /// # }
919                            ///
920                            /// const RETRYABLE_ERROR_CODES: &[&str] = &[
921                            ///     // List error codes to be retried here...
922                            /// ];
923                            ///
924                            /// // When classifying at an operation's error type, classifiers require a generic parameter.
925                            /// // When classifying the HTTP response alone, no generic is needed.
926                            /// #[derive(Debug, Default)]
927                            /// pub struct ExampleErrorCodeClassifier<E> {
928                            ///     _inner: PhantomData<E>,
929                            /// }
930                            ///
931                            /// impl<E> ExampleErrorCodeClassifier<E> {
932                            ///     pub fn new() -> Self {
933                            ///         Self {
934                            ///             _inner: PhantomData,
935                            ///         }
936                            ///     }
937                            /// }
938                            ///
939                            /// impl<E> ClassifyRetry for ExampleErrorCodeClassifier<E>
940                            /// where
941                            ///     // Adding a trait bound for ProvideErrorMetadata allows us to inspect the error code.
942                            ///     E: StdError + ProvideErrorMetadata + Send + Sync + 'static,
943                            /// {
944                            ///     fn classify_retry(&self, ctx: &InterceptorContext) -> RetryAction {
945                            ///         // Check for a result
946                            ///         let output_or_error = ctx.output_or_error();
947                            ///         // Check for an error
948                            ///         let error = match output_or_error {
949                            ///             Some(Ok(_)) | None => return RetryAction::NoActionIndicated,
950                            ///               Some(Err(err)) => err,
951                            ///         };
952                            ///
953                            ///         // Downcast the generic error and extract the code
954                            ///         let error_code = OrchestratorError::as_operation_error(error)
955                            ///             .and_then(|err| err.downcast_ref::<E>())
956                            ///             .and_then(|err| err.code());
957                            ///
958                            ///         // If this error's code is in our list, return an action that tells the RetryStrategy to retry this request.
959                            ///         if let Some(error_code) = error_code {
960                            ///             if RETRYABLE_ERROR_CODES.contains(&error_code) {
961                            ///                 return RetryAction::transient_error();
962                            ///             }
963                            ///         }
964                            ///
965                            ///         // Otherwise, return that no action is indicated i.e. that this classifier doesn't require a retry.
966                            ///         // Another classifier may still classify this response as retryable.
967                            ///         RetryAction::NoActionIndicated
968                            ///     }
969                            ///
970                            ///     fn name(&self) -> &'static str { "Example Error Code Classifier" }
971                            /// }
972                            ///
973                            /// let config = Config::builder()
974                            ///     .retry_classifier(ExampleErrorCodeClassifier::<SomeOperationError>::new())
975                            ///     .build();
976                            /// # }
977                            /// ```
978                            pub fn retry_classifier(mut self, retry_classifier: impl ::aws_smithy_runtime_api::client::retries::classifiers::ClassifyRetry + 'static) -> Self {
979                                self.push_retry_classifier(::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier::new(retry_classifier));
980                                self
981                            }
982    
983                            /// Like [`Self::retry_classifier`], but takes a [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier).
984                            pub fn push_retry_classifier(&mut self, retry_classifier: ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier) -> &mut Self {
985                                self.runtime_components.push_retry_classifier(retry_classifier);
986                                self
987                            }
988    
989                            /// Set [`SharedRetryClassifier`](::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier)s for the builder, replacing any that
990                            /// were previously set.
991                            pub fn set_retry_classifiers(&mut self, retry_classifiers: impl IntoIterator<Item = ::aws_smithy_runtime_api::client::retries::classifiers::SharedRetryClassifier>) -> &mut Self {
992                                self.runtime_components.set_retry_classifiers(retry_classifiers.into_iter());
993                                self
994                            }
995    /// Sets the name of the app that is using the client.
996                                ///
997                                /// This _optional_ name is used to identify the application in the user agent that
998                                /// gets sent along with requests.
999                                pub fn app_name(mut self, app_name: ::aws_types::app_name::AppName) -> Self {
1000                                    self.set_app_name(Some(app_name));
1001                                    self
1002                                }
1003    /// Sets the name of the app that is using the client.
1004                                ///
1005                                /// This _optional_ name is used to identify the application in the user agent that
1006                                /// gets sent along with requests.
1007                                pub fn set_app_name(&mut self, app_name: ::std::option::Option<::aws_types::app_name::AppName>) -> &mut Self {
1008                                    self.config.store_or_unset(app_name);
1009                                    self
1010                                }
1011    /// Overrides the default invocation ID generator.
1012    /// 
1013    /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
1014    pub fn invocation_id_generator(mut self, gen: impl ::aws_runtime::invocation_id::InvocationIdGenerator + 'static) -> Self {
1015                                self.set_invocation_id_generator(::std::option::Option::Some(::aws_runtime::invocation_id::SharedInvocationIdGenerator::new(gen)));
1016                                self
1017                            }
1018    /// Overrides the default invocation ID generator.
1019    /// 
1020    /// The invocation ID generator generates ID values for the `amz-sdk-invocation-id` header. By default, this will be a random UUID. Overriding it may be useful in tests that examine the HTTP request and need to be deterministic.
1021    pub fn set_invocation_id_generator(&mut self, gen: ::std::option::Option<::aws_runtime::invocation_id::SharedInvocationIdGenerator>) -> &mut Self {
1022                                self.config.store_or_unset(gen);
1023                                self
1024                            }
1025    /// Sets the endpoint URL used to communicate with this service.
1026    ///
1027    /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1028    /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1029    /// [`Builder::endpoint_resolver`].
1030    pub fn endpoint_url(mut self, endpoint_url: impl Into<::std::string::String>) -> Self {
1031                                    self.set_endpoint_url(Some(endpoint_url.into()));
1032                                    self
1033                        }
1034    /// Sets the endpoint URL used to communicate with this service.
1035    ///
1036    /// Note: this is used in combination with other endpoint rules, e.g. an API that applies a host-label prefix
1037    /// will be prefixed onto this URL. To fully override the endpoint resolver, use
1038    /// [`Builder::endpoint_resolver`].
1039    pub fn set_endpoint_url(&mut self, endpoint_url: Option<::std::string::String>) -> &mut Self {
1040                                    self.config.store_or_unset(endpoint_url.map(::aws_types::endpoint_config::EndpointUrl));
1041                                    self
1042                                }
1043    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
1044    pub fn use_dual_stack(mut self, use_dual_stack: impl Into<bool>) -> Self {
1045                                    self.set_use_dual_stack(Some(use_dual_stack.into()));
1046                                    self
1047                        }
1048    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
1049    pub fn set_use_dual_stack(&mut self, use_dual_stack: Option<bool>) -> &mut Self {
1050                                    self.config.store_or_unset(use_dual_stack.map(::aws_types::endpoint_config::UseDualStack));
1051                                    self
1052                                }
1053    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
1054    pub fn use_fips(mut self, use_fips: impl Into<bool>) -> Self {
1055                                    self.set_use_fips(Some(use_fips.into()));
1056                                    self
1057                        }
1058    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
1059    pub fn set_use_fips(&mut self, use_fips: Option<bool>) -> &mut Self {
1060                                    self.config.store_or_unset(use_fips.map(::aws_types::endpoint_config::UseFips));
1061                                    self
1062                                }
1063    /// Sets the AWS region to use when making requests.
1064                            ///
1065                            /// # Examples
1066                            /// ```no_run
1067                            /// use aws_types::region::Region;
1068                            /// use aws_sdk_transcribestreaming::config::{Builder, Config};
1069                            ///
1070                            /// let config = aws_sdk_transcribestreaming::Config::builder()
1071                            ///     .region(Region::new("us-east-1"))
1072                            ///     .build();
1073                            /// ```
1074                            pub fn region(mut self, region: impl ::std::convert::Into<::std::option::Option<crate::config::Region>>) -> Self {
1075                                self.set_region(region.into());
1076                                self
1077                            }
1078    /// Sets the AWS region to use when making requests.
1079                            pub fn set_region(&mut self, region: ::std::option::Option<crate::config::Region>) -> &mut Self {
1080                                self.config.store_or_unset(region);
1081                                self
1082                            }
1083    /// Sets the credentials provider for this service
1084                            pub fn credentials_provider(mut self, credentials_provider: impl crate::config::ProvideCredentials + 'static) -> Self {
1085                                self.set_credentials_provider(::std::option::Option::Some(crate::config::SharedCredentialsProvider::new(credentials_provider)));
1086                                self
1087                            }
1088    /// Sets the credentials provider for this service
1089                            pub fn set_credentials_provider(&mut self, credentials_provider: ::std::option::Option<crate::config::SharedCredentialsProvider>) -> &mut Self {
1090        if let Some(credentials_provider) = credentials_provider {
1091            self.runtime_components.set_identity_resolver(::aws_runtime::auth::sigv4::SCHEME_ID, credentials_provider);
1092        }
1093        self
1094    }
1095    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1096                    ///
1097                    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1098                    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1099                    /// all operations might be the ideal behavior but could break existing applications.
1100                    ///
1101                    /// # Examples
1102                    ///
1103                    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1104                    /// ```no_run
1105                    /// use aws_sdk_transcribestreaming::config::BehaviorVersion;
1106                    ///
1107                    /// let config = aws_sdk_transcribestreaming::Config::builder()
1108                    ///     .behavior_version(BehaviorVersion::latest())
1109                    ///     // ...
1110                    ///     .build();
1111                    /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
1112                    /// ```
1113                    ///
1114                    /// Customizing behavior major version:
1115                    /// ```no_run
1116                    /// use aws_sdk_transcribestreaming::config::BehaviorVersion;
1117                    ///
1118                    /// let config = aws_sdk_transcribestreaming::Config::builder()
1119                    ///     .behavior_version(BehaviorVersion::v2023_11_09())
1120                    ///     // ...
1121                    ///     .build();
1122                    /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
1123                    /// ```
1124                ///
1125                    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
1126                        self.set_behavior_version(Some(behavior_version));
1127                        self
1128                    }
1129    
1130                    
1131                    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
1132                    ///
1133                    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
1134                    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
1135                    /// all operations might be the ideal behavior but could break existing applications.
1136                    ///
1137                    /// # Examples
1138                    ///
1139                    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
1140                    /// ```no_run
1141                    /// use aws_sdk_transcribestreaming::config::BehaviorVersion;
1142                    ///
1143                    /// let config = aws_sdk_transcribestreaming::Config::builder()
1144                    ///     .behavior_version(BehaviorVersion::latest())
1145                    ///     // ...
1146                    ///     .build();
1147                    /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
1148                    /// ```
1149                    ///
1150                    /// Customizing behavior major version:
1151                    /// ```no_run
1152                    /// use aws_sdk_transcribestreaming::config::BehaviorVersion;
1153                    ///
1154                    /// let config = aws_sdk_transcribestreaming::Config::builder()
1155                    ///     .behavior_version(BehaviorVersion::v2023_11_09())
1156                    ///     // ...
1157                    ///     .build();
1158                    /// let client = aws_sdk_transcribestreaming::Client::from_conf(config);
1159                    /// ```
1160                ///
1161                    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
1162                        self.behavior_version = behavior_version;
1163                        self
1164                    }
1165    
1166                    /// Convenience method to set the latest behavior major version
1167                    ///
1168                    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
1169                    pub fn behavior_version_latest(mut self) -> Self {
1170                        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
1171                        self
1172                    }
1173    /// Adds a runtime plugin to the config.
1174    #[allow(unused)]
1175    pub(crate) fn runtime_plugin(mut self, plugin: impl crate::config::RuntimePlugin + 'static) -> Self {
1176                        self.push_runtime_plugin(crate::config::SharedRuntimePlugin::new(plugin));
1177                        self
1178                    }
1179    /// Adds a runtime plugin to the config.
1180    #[allow(unused)]
1181    pub(crate) fn push_runtime_plugin(&mut self, plugin: crate::config::SharedRuntimePlugin) -> &mut Self {
1182                        self.runtime_plugins.push(plugin);
1183                        self
1184                    }
1185    #[cfg(any(feature = "test-util", test))]
1186    #[allow(unused_mut)]
1187    /// Apply test defaults to the builder
1188    pub fn apply_test_defaults(&mut self) -> &mut Self {
1189        self
1190                                    .set_time_source(::std::option::Option::Some(::aws_smithy_async::time::SharedTimeSource::new(
1191                                        ::aws_smithy_async::time::StaticTimeSource::new(::std::time::UNIX_EPOCH + ::std::time::Duration::from_secs(1234567890)))
1192                                    ));
1193        self.config.store_put(::aws_runtime::user_agent::AwsUserAgent::for_tests());
1194        self.set_credentials_provider(Some(crate::config::SharedCredentialsProvider::new(::aws_credential_types::Credentials::for_tests())));
1195        self.behavior_version = ::std::option::Option::Some(crate::config::BehaviorVersion::latest());
1196        self
1197    }
1198    #[cfg(any(feature = "test-util", test))]
1199    #[allow(unused_mut)]
1200    /// Apply test defaults to the builder
1201    pub fn with_test_defaults(mut self) -> Self {
1202        self.apply_test_defaults(); self
1203    }
1204    /// Builds a [`Config`].
1205    #[allow(unused_mut)]
1206    pub fn build(mut self) -> Config {
1207        let mut layer = self.config;
1208        if self.runtime_components.time_source().is_none() {
1209                                    self.runtime_components.set_time_source(::std::option::Option::Some(::std::default::Default::default()));
1210                                }
1211        layer.store_put(crate::meta::API_METADATA.clone());
1212        layer.store_put(::aws_types::SigningName::from_static("transcribe"));
1213                                    layer.load::<::aws_types::region::Region>().cloned().map(|r| layer.store_put(::aws_types::region::SigningRegion::from(r)));
1214        Config {
1215            config: crate::config::Layer::from(layer.clone()).with_name("aws_sdk_transcribestreaming::config::Config").freeze(),
1216                                    cloneable: layer,
1217                                    runtime_components: self.runtime_components,
1218                                    runtime_plugins: self.runtime_plugins,
1219                                    behavior_version: self.behavior_version,
1220        }
1221    }
1222}
1223#[derive(::std::fmt::Debug)]
1224            pub(crate) struct ServiceRuntimePlugin {
1225                config: ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer>,
1226                runtime_components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1227            }
1228
1229            impl ServiceRuntimePlugin {
1230                pub fn new(_service_config: crate::config::Config) -> Self {
1231                    let config = { let mut cfg = ::aws_smithy_types::config_bag::Layer::new("Transcribe");
1232                            cfg.store_put(::aws_smithy_runtime::client::orchestrator::AuthSchemeAndEndpointOrchestrationV2);
1233                            ::std::option::Option::Some(cfg.freeze()) };
1234                    let mut runtime_components = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("ServiceRuntimePlugin");
1235                    runtime_components.set_auth_scheme_option_resolver(::std::option::Option::Some({
1236            use crate::config::auth::ResolveAuthScheme;
1237            crate::config::auth::DefaultAuthSchemeResolver::default().into_shared_resolver()
1238            }));
1239runtime_components.set_endpoint_resolver(::std::option::Option::Some({
1240            use crate::config::endpoint::ResolveEndpoint;
1241            crate::config::endpoint::DefaultResolver::new().into_shared_resolver()
1242            }));
1243runtime_components.push_interceptor(::aws_smithy_runtime::client::http::connection_poisoning::ConnectionPoisoningInterceptor::new());
1244runtime_components.push_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::HttpStatusCodeClassifier::default());
1245runtime_components.push_interceptor(crate::sdk_feature_tracker::retry_mode::RetryModeFeatureTrackerInterceptor::new());
1246runtime_components.push_interceptor(::aws_runtime::service_clock_skew::ServiceClockSkewInterceptor::new());
1247runtime_components.push_interceptor(::aws_runtime::request_info::RequestInfoInterceptor::new());
1248runtime_components.push_interceptor(::aws_runtime::user_agent::UserAgentInterceptor::new());
1249runtime_components.push_interceptor(::aws_runtime::invocation_id::InvocationIdInterceptor::new());
1250runtime_components.push_interceptor(::aws_runtime::recursion_detection::RecursionDetectionInterceptor::new());
1251runtime_components.push_auth_scheme(::aws_smithy_runtime_api::client::auth::SharedAuthScheme::new(::aws_runtime::auth::sigv4::SigV4AuthScheme::new()));
1252                    Self { config, runtime_components }
1253                }
1254            }
1255
1256            impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ServiceRuntimePlugin {
1257                fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1258                    self.config.clone()
1259                }
1260
1261                fn order(&self) -> ::aws_smithy_runtime_api::client::runtime_plugin::Order {
1262                    ::aws_smithy_runtime_api::client::runtime_plugin::Order::Defaults
1263                }
1264
1265                fn runtime_components(&self, _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1266                    ::std::borrow::Cow::Borrowed(&self.runtime_components)
1267                }
1268            }
1269
1270            // Cross-operation shared-state singletons
1271            
1272/// A plugin that enables configuration for a single operation invocation
1273            ///
1274            /// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
1275            /// In the case of default values requested, they will be obtained from `client_config`.
1276            #[derive(Debug)]
1277            pub(crate) struct ConfigOverrideRuntimePlugin {
1278                pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
1279                pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
1280            }
1281
1282            impl ConfigOverrideRuntimePlugin {
1283                #[allow(dead_code)] // unused when a service does not provide any operations
1284                pub(crate) fn new(
1285                    config_override: Builder,
1286                    initial_config: ::aws_smithy_types::config_bag::FrozenLayer,
1287                    initial_components: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder
1288                ) -> Self {
1289                    let mut layer = config_override.config;
1290                    let mut components = config_override.runtime_components;
1291                    #[allow(unused_mut)]
1292                    let mut resolver = ::aws_smithy_runtime::client::config_override::Resolver::overrid(initial_config, initial_components, &mut layer, &mut components);
1293
1294                    resolver.config_mut()
1295                                .load::<::aws_types::region::Region>()
1296                                .cloned()
1297                                .map(|r| resolver.config_mut().store_put(::aws_types::region::SigningRegion::from(r)));
1298
1299                    let _ = resolver;
1300                    Self {
1301                        config: ::aws_smithy_types::config_bag::Layer::from(layer)
1302                            .with_name("aws_sdk_transcribestreaming::config::ConfigOverrideRuntimePlugin").freeze(),
1303                        components,
1304                    }
1305                }
1306            }
1307
1308            impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for ConfigOverrideRuntimePlugin {
1309                fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
1310                    Some(self.config.clone())
1311                }
1312
1313                fn runtime_components(&self, _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
1314                    ::std::borrow::Cow::Borrowed(&self.components)
1315                }
1316            }
1317
1318pub use ::aws_smithy_types::config_bag::ConfigBag;
1319                pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponents;
1320                pub use ::aws_smithy_runtime::client::identity::IdentityCache;
1321
1322pub use ::aws_credential_types::Credentials;
1323
1324impl From<&::aws_types::sdk_config::SdkConfig> for Builder {
1325                    fn from(input: &::aws_types::sdk_config::SdkConfig) -> Self {
1326                        let mut builder = Builder::default();
1327                        builder.set_credentials_provider(input.credentials_provider());
1328builder =
1329                         builder.region(input.region().cloned());
1330builder.set_use_fips(input.use_fips());
1331builder.set_use_dual_stack(input.use_dual_stack());
1332if input.get_origin("endpoint_url").is_client_config() {
1333                builder.set_endpoint_url(input.endpoint_url().map(|s|s.to_string()));
1334            } else {
1335                builder.set_endpoint_url(
1336                    input
1337                        .service_config()
1338                        .and_then(|conf| conf.load_config(service_config_key("Transcribe Streaming", "AWS_ENDPOINT_URL", "endpoint_url")).map(|it| it.parse().unwrap()))
1339                        .or_else(|| input.endpoint_url().map(|s|s.to_string()))
1340                );
1341            }
1342// resiliency
1343                    builder.set_retry_config(input.retry_config().cloned());
1344                    builder.set_timeout_config(input.timeout_config().cloned());
1345                    builder.set_sleep_impl(input.sleep_impl());
1346
1347                    builder.set_http_client(input.http_client());
1348                    builder.set_time_source(input.time_source());
1349                    builder.set_behavior_version(input.behavior_version());
1350                    builder.set_auth_scheme_preference(input.auth_scheme_preference().cloned());
1351                    // setting `None` here removes the default
1352                    if let Some(config) = input.stalled_stream_protection() {
1353                        builder.set_stalled_stream_protection(Some(config));
1354                    }
1355
1356                    if let Some(cache) = input.identity_cache() {
1357                        builder.set_identity_cache(cache);
1358                    }
1359builder.set_app_name(input.app_name().cloned());
1360
1361                        builder
1362                    }
1363                }
1364
1365                impl From<&::aws_types::sdk_config::SdkConfig> for Config {
1366                    fn from(sdk_config: &::aws_types::sdk_config::SdkConfig) -> Self {
1367                        Builder::from(sdk_config).build()
1368                    }
1369                }
1370
1371pub use ::aws_types::app_name::AppName;
1372
1373#[allow(dead_code)]
1374fn service_config_key<'a>(
1375                    service_id: &'a str,
1376                    env: &'a str,
1377                    profile: &'a str,
1378                ) -> aws_types::service_config::ServiceConfigKey<'a> {
1379                    ::aws_types::service_config::ServiceConfigKey::builder()
1380                        .service_id(service_id)
1381                        .env(env)
1382                        .profile(profile)
1383                        .build()
1384                        .expect("all field sets explicitly, can't fail")
1385                }
1386
1387pub use ::aws_smithy_async::rt::sleep::{Sleep};
1388
1389pub(crate) fn base_client_runtime_plugins(
1390                    mut config: crate::Config,
1391                ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
1392                    let mut configured_plugins = ::std::vec::Vec::new();
1393                    ::std::mem::swap(&mut config.runtime_plugins, &mut configured_plugins);
1394                    #[cfg(feature = "behavior-version-latest")] {
1395    if config.behavior_version.is_none() {
1396                                    config.behavior_version = Some(::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion::latest());
1397                                }
1398}
1399
1400                    let default_retry_partition = "transcribestreaming";
1401                    let default_retry_partition = match config.region() {
1402                            Some(region) => ::std::borrow::Cow::from(format!("{default_retry_partition}-{}", region)),
1403                            None => ::std::borrow::Cow::from(default_retry_partition),
1404                        };
1405
1406                    let scope = "aws-sdk-transcribestreaming";
1407
1408                    let mut plugins = ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins::new()
1409                        // defaults
1410                        .with_client_plugins(::aws_smithy_runtime::client::defaults::default_plugins(
1411                            ::aws_smithy_runtime::client::defaults::DefaultPluginParams::new()
1412                                .with_retry_partition_name(default_retry_partition)
1413                                .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."))
1414                        ))
1415                        // user config
1416                        .with_client_plugin(
1417                            ::aws_smithy_runtime_api::client::runtime_plugin::StaticRuntimePlugin::new()
1418                                .with_config(config.config.clone())
1419                                .with_runtime_components(config.runtime_components.clone())
1420                        )
1421                        // codegen config
1422                        .with_client_plugin(crate::config::ServiceRuntimePlugin::new(config.clone()))
1423                        .with_client_plugin(::aws_smithy_runtime::client::auth::no_auth::NoAuthRuntimePlugin::new())
1424                        .with_client_plugin(
1425                            ::aws_smithy_runtime::client::metrics::MetricsRuntimePlugin::builder()
1426                                .with_scope(scope)
1427                                .with_time_source(config.runtime_components.time_source().unwrap_or_default())
1428                                .build()
1429                                .expect("All required fields have been set")
1430                        );
1431
1432                    
1433
1434                    for plugin in configured_plugins {
1435                        plugins = plugins.with_client_plugin(plugin);
1436                    }
1437                    plugins
1438                }
1439
1440pub use ::aws_smithy_types::config_bag::FrozenLayer;
1441
1442pub use ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder;
1443
1444pub use ::aws_smithy_runtime_api::client::runtime_plugin::SharedRuntimePlugin;
1445
1446pub use ::aws_smithy_runtime_api::client::behavior_version::BehaviorVersion;
1447
1448pub use ::aws_smithy_runtime_api::client::stalled_stream_protection::StalledStreamProtectionConfig;
1449
1450pub use ::aws_smithy_runtime_api::client::http::SharedHttpClient;
1451
1452pub use ::aws_smithy_async::rt::sleep::SharedAsyncSleep;
1453
1454pub use ::aws_smithy_runtime_api::client::identity::SharedIdentityCache;
1455
1456pub use ::aws_smithy_runtime_api::client::interceptors::SharedInterceptor;
1457
1458pub use ::aws_types::region::Region;
1459
1460pub use ::aws_credential_types::provider::SharedCredentialsProvider;
1461
1462pub use ::aws_smithy_runtime_api::client::http::HttpClient;
1463
1464pub use ::aws_smithy_runtime_api::shared::IntoShared;
1465
1466pub use ::aws_smithy_async::rt::sleep::AsyncSleep;
1467
1468pub use ::aws_smithy_runtime_api::client::identity::ResolveCachedIdentity;
1469
1470pub use ::aws_smithy_runtime_api::client::interceptors::Intercept;
1471
1472pub use ::aws_credential_types::provider::ProvideCredentials;
1473
1474pub use ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin;
1475
1476pub use ::aws_smithy_types::config_bag::Layer;
1477
1478/// Types needed to configure endpoint resolution.
1479pub mod endpoint;
1480
1481/// HTTP request and response types.
1482pub mod http;
1483
1484/// Types needed to implement [`Intercept`](crate::config::Intercept).
1485pub mod interceptors;
1486
1487/// Retry configuration.
1488pub mod retry;
1489
1490/// Timeout configuration.
1491pub mod timeout;
1492
1493/// Types needed to configure auth scheme resolution.
1494pub mod auth;
1495