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