Skip to main content

aws_sdk_efs/operation/
update_file_system_protection.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `UpdateFileSystemProtection`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct UpdateFileSystemProtection;
6impl UpdateFileSystemProtection {
7    /// Creates a new `UpdateFileSystemProtection`
8    pub fn new() -> Self {
9        Self
10    }
11    pub(crate) async fn orchestrate(
12        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
13        input: crate::operation::update_file_system_protection::UpdateFileSystemProtectionInput,
14    ) -> ::std::result::Result<
15        crate::operation::update_file_system_protection::UpdateFileSystemProtectionOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::update_file_system_protection::UpdateFileSystemProtectionError,
18            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
19        >,
20    > {
21        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
22            ::aws_smithy_runtime_api::client::interceptors::context::Error,
23            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
24        >| {
25            err.map_service_error(|err| {
26                err.downcast::<crate::operation::update_file_system_protection::UpdateFileSystemProtectionError>()
27                    .expect("correct error type")
28            })
29        };
30        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
31            .await
32            .map_err(map_err)?;
33        let output = context.finalize().map_err(map_err)?;
34        ::std::result::Result::Ok(
35            output
36                .downcast::<crate::operation::update_file_system_protection::UpdateFileSystemProtectionOutput>()
37                .expect("correct output type"),
38        )
39    }
40
41    pub(crate) async fn orchestrate_with_stop_point(
42        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
43        input: crate::operation::update_file_system_protection::UpdateFileSystemProtectionInput,
44        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
45    ) -> ::std::result::Result<
46        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
47        ::aws_smithy_runtime_api::client::result::SdkError<
48            ::aws_smithy_runtime_api::client::interceptors::context::Error,
49            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
50        >,
51    > {
52        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
53        use ::tracing::Instrument;
54        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("EFS", "UpdateFileSystemProtection", input, runtime_plugins, stop_point)
55            // Create a parent span for the entire operation. Includes a random, internal-only,
56            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
57            .instrument(::tracing::debug_span!(
58                "EFS.UpdateFileSystemProtection",
59                "rpc.service" = "EFS",
60                "rpc.method" = "UpdateFileSystemProtection",
61                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
62                "rpc.system" = "aws-api",
63            ))
64            .await
65    }
66
67    pub(crate) fn operation_runtime_plugins(
68        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
69        client_config: &crate::config::Config,
70        config_override: ::std::option::Option<crate::config::Builder>,
71    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
72        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
73
74        if let ::std::option::Option::Some(config_override) = config_override {
75            for plugin in config_override.runtime_plugins.iter().cloned() {
76                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
77            }
78            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
79                config_override,
80                client_config.config.clone(),
81                &client_config.runtime_components,
82            ));
83        }
84        runtime_plugins
85    }
86}
87impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for UpdateFileSystemProtection {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("UpdateFileSystemProtection");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            UpdateFileSystemProtectionRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            UpdateFileSystemProtectionResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("UpdateFileSystemProtection")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
106            "UpdateFileSystemProtection",
107            "EFS",
108        ));
109        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
110        signing_options.double_uri_encode = true;
111        signing_options.content_sha256_header = false;
112        signing_options.normalize_uri_path = true;
113        signing_options.payload_override = None;
114
115        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
116            signing_options,
117            ..::std::default::Default::default()
118        });
119
120        ::std::option::Option::Some(cfg.freeze())
121    }
122
123    fn runtime_components(
124        &self,
125        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
126    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
127        #[allow(unused_mut)]
128        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UpdateFileSystemProtection")
129            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
130                UpdateFileSystemProtectionTelemetryInputCaptureInterceptor,
131            ))
132            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
133                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
134            ))
135            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
136                UpdateFileSystemProtectionEndpointParamsInterceptor,
137            ))
138            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
139                crate::operation::update_file_system_protection::UpdateFileSystemProtectionError,
140            >::new())
141            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
142                crate::operation::update_file_system_protection::UpdateFileSystemProtectionError,
143            >::new())
144            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
145                crate::operation::update_file_system_protection::UpdateFileSystemProtectionError,
146            >::new())
147            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
148                crate::operation::update_file_system_protection::UpdateFileSystemProtectionError,
149            >::new());
150
151        ::std::borrow::Cow::Owned(rcb)
152    }
153}
154
155#[derive(Debug)]
156struct UpdateFileSystemProtectionTelemetryInputCaptureInterceptor;
157
158#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
159impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateFileSystemProtectionTelemetryInputCaptureInterceptor {
160    fn name(&self) -> &'static str {
161        "UpdateFileSystemProtectionTelemetryInputCaptureInterceptor"
162    }
163
164    fn read_before_execution(
165        &self,
166        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
167            '_,
168            ::aws_smithy_runtime_api::client::interceptors::context::Input,
169            ::aws_smithy_runtime_api::client::interceptors::context::Output,
170            ::aws_smithy_runtime_api::client::interceptors::context::Error,
171        >,
172        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
173    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
174        // Nothing to do unless the customer opted in by naming members to record.
175        let ::std::option::Option::Some(requested) = cfg
176            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
177            .filter(|r| !r.is_empty())
178        else {
179            return ::std::result::Result::Ok(());
180        };
181
182        let ::std::option::Option::Some(input) = context.input().downcast_ref::<UpdateFileSystemProtectionInput>() else {
183            // A mismatched input is not this interceptor's concern; skip quietly.
184            return ::std::result::Result::Ok(());
185        };
186
187        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
188        if requested.should_capture("FileSystemId") {
189            if let ::std::option::Option::Some(value) = input.file_system_id.as_deref() {
190                captured.insert("FileSystemId", value);
191            }
192        }
193
194        cfg.interceptor_state().store_put(captured);
195        ::std::result::Result::Ok(())
196    }
197}
198#[derive(Debug)]
199struct UpdateFileSystemProtectionResponseDeserializer;
200impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateFileSystemProtectionResponseDeserializer {
201    fn deserialize_nonstreaming_with_config(
202        &self,
203        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
204        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
205    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
206        let (success, status) = (response.status().is_success(), response.status().as_u16());
207        let headers = response.headers();
208        let body = response.body().bytes().expect("body loaded");
209        #[allow(unused_mut)]
210        let mut force_error = false;
211        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
212        let parse_result = if !success && status != 200 || force_error {
213            crate::protocol_serde::shape_update_file_system_protection::de_update_file_system_protection_http_error(status, headers, body)
214        } else {
215            crate::protocol_serde::shape_update_file_system_protection::de_update_file_system_protection_http_response(status, headers, body)
216        };
217        crate::protocol_serde::type_erase_result(parse_result)
218    }
219}
220#[derive(Debug)]
221struct UpdateFileSystemProtectionRequestSerializer;
222impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateFileSystemProtectionRequestSerializer {
223    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
224    fn serialize_input(
225        &self,
226        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
227        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
228    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
229        let input = input
230            .downcast::<crate::operation::update_file_system_protection::UpdateFileSystemProtectionInput>()
231            .expect("correct type");
232        let _header_serialization_settings = _cfg
233            .load::<crate::serialization_settings::HeaderSerializationSettings>()
234            .cloned()
235            .unwrap_or_default();
236        let mut request_builder = {
237            #[allow(clippy::uninlined_format_args)]
238            fn uri_base(
239                _input: &crate::operation::update_file_system_protection::UpdateFileSystemProtectionInput,
240                output: &mut ::std::string::String,
241            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
242                use ::std::fmt::Write as _;
243                let input_1 = &_input.file_system_id;
244                let input_1 = input_1
245                    .as_ref()
246                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("file_system_id", "cannot be empty or unset"))?;
247                let file_system_id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
248                if file_system_id.is_empty() {
249                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
250                        "file_system_id",
251                        "cannot be empty or unset",
252                    ));
253                }
254                ::std::write!(
255                    output,
256                    "/2015-02-01/file-systems/{FileSystemId}/protection",
257                    FileSystemId = file_system_id
258                )
259                .expect("formatting should succeed");
260                ::std::result::Result::Ok(())
261            }
262            #[allow(clippy::unnecessary_wraps)]
263            fn update_http_builder(
264                input: &crate::operation::update_file_system_protection::UpdateFileSystemProtectionInput,
265                builder: ::http_1x::request::Builder,
266            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
267                let mut uri = ::std::string::String::new();
268                uri_base(input, &mut uri)?;
269                ::std::result::Result::Ok(builder.method("PUT").uri(uri))
270            }
271            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
272            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/json");
273            builder
274        };
275        let body = ::aws_smithy_types::body::SdkBody::from(
276            crate::protocol_serde::shape_update_file_system_protection::ser_update_file_system_protection_input(&input)?,
277        );
278        if let Some(content_length) = body.content_length() {
279            let content_length = content_length.to_string();
280            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
281        }
282        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
283    }
284}
285#[derive(Debug)]
286struct UpdateFileSystemProtectionEndpointParamsInterceptor;
287
288#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
289impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateFileSystemProtectionEndpointParamsInterceptor {
290    fn name(&self) -> &'static str {
291        "UpdateFileSystemProtectionEndpointParamsInterceptor"
292    }
293
294    fn read_before_execution(
295        &self,
296        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
297            '_,
298            ::aws_smithy_runtime_api::client::interceptors::context::Input,
299            ::aws_smithy_runtime_api::client::interceptors::context::Output,
300            ::aws_smithy_runtime_api::client::interceptors::context::Error,
301        >,
302        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
303    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
304        let _input = context
305            .input()
306            .downcast_ref::<UpdateFileSystemProtectionInput>()
307            .ok_or("failed to downcast to UpdateFileSystemProtectionInput")?;
308
309        let params = crate::config::endpoint::Params::builder()
310            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
311            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
312            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
313            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
314            .build()
315            .map_err(|err| {
316                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
317            })?;
318        cfg.interceptor_state()
319            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
320        ::std::result::Result::Ok(())
321    }
322}
323
324// The get_* functions below are generated from JMESPath expressions in the
325// operationContextParams trait. They target the operation's input shape.
326
327/// Error type for the `UpdateFileSystemProtectionError` operation.
328#[non_exhaustive]
329#[derive(::std::fmt::Debug)]
330pub enum UpdateFileSystemProtectionError {
331    /// <p>Returned if the request is malformed or contains an error such as an invalid parameter value or a missing required parameter.</p>
332    BadRequest(crate::types::error::BadRequest),
333    /// <p>Returned if the specified <code>FileSystemId</code> value doesn't exist in the requester's Amazon Web Services account.</p>
334    FileSystemNotFound(crate::types::error::FileSystemNotFound),
335    /// <p>Returned if the file system's lifecycle state is not "available".</p>
336    IncorrectFileSystemLifeCycleState(crate::types::error::IncorrectFileSystemLifeCycleState),
337    /// <p>Returned if there's not enough capacity to provision additional throughput. This value might be returned when you try to create a file system in provisioned throughput mode, when you attempt to increase the provisioned throughput of an existing file system, or when you attempt to change an existing file system from Bursting Throughput to Provisioned Throughput mode. Try again later.</p>
338    InsufficientThroughputCapacity(crate::types::error::InsufficientThroughputCapacity),
339    /// <p>Returned if an error occurred on the server side.</p>
340    InternalServerError(crate::types::error::InternalServerError),
341    /// <p>Returned if the file system is already included in a replication configuration.&gt;</p>
342    ReplicationAlreadyExists(crate::types::error::ReplicationAlreadyExists),
343    /// <p>Returned if the throughput mode or amount of provisioned throughput can't be changed because the throughput limit of 1024 MiB/s has been reached.</p>
344    ThroughputLimitExceeded(crate::types::error::ThroughputLimitExceeded),
345    /// <p>Returned if you don’t wait at least 24 hours before either changing the throughput mode, or decreasing the Provisioned Throughput value.</p>
346    TooManyRequests(crate::types::error::TooManyRequests),
347    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
348    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
349    variable wildcard pattern and check `.code()`:
350     \
351    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
352     \
353    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-UpdateFileSystemProtectionError) for what information is available for the error.")]
354    Unhandled(crate::error::sealed_unhandled::Unhandled),
355}
356impl UpdateFileSystemProtectionError {
357    /// Creates the `UpdateFileSystemProtectionError::Unhandled` variant from any error type.
358    pub fn unhandled(
359        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
360    ) -> Self {
361        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
362            source: err.into(),
363            meta: ::std::default::Default::default(),
364        })
365    }
366
367    /// Creates the `UpdateFileSystemProtectionError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
368    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
369        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
370            source: err.clone().into(),
371            meta: err,
372        })
373    }
374    ///
375    /// Returns error metadata, which includes the error code, message,
376    /// request ID, and potentially additional information.
377    ///
378    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
379        match self {
380            Self::BadRequest(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
381            Self::FileSystemNotFound(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
382            Self::IncorrectFileSystemLifeCycleState(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
383            Self::InsufficientThroughputCapacity(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
384            Self::InternalServerError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
385            Self::ReplicationAlreadyExists(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
386            Self::ThroughputLimitExceeded(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
387            Self::TooManyRequests(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
388            Self::Unhandled(e) => &e.meta,
389        }
390    }
391    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::BadRequest`.
392    pub fn is_bad_request(&self) -> bool {
393        matches!(self, Self::BadRequest(_))
394    }
395    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::FileSystemNotFound`.
396    pub fn is_file_system_not_found(&self) -> bool {
397        matches!(self, Self::FileSystemNotFound(_))
398    }
399    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::IncorrectFileSystemLifeCycleState`.
400    pub fn is_incorrect_file_system_life_cycle_state(&self) -> bool {
401        matches!(self, Self::IncorrectFileSystemLifeCycleState(_))
402    }
403    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::InsufficientThroughputCapacity`.
404    pub fn is_insufficient_throughput_capacity(&self) -> bool {
405        matches!(self, Self::InsufficientThroughputCapacity(_))
406    }
407    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::InternalServerError`.
408    pub fn is_internal_server_error(&self) -> bool {
409        matches!(self, Self::InternalServerError(_))
410    }
411    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::ReplicationAlreadyExists`.
412    pub fn is_replication_already_exists(&self) -> bool {
413        matches!(self, Self::ReplicationAlreadyExists(_))
414    }
415    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::ThroughputLimitExceeded`.
416    pub fn is_throughput_limit_exceeded(&self) -> bool {
417        matches!(self, Self::ThroughputLimitExceeded(_))
418    }
419    /// Returns `true` if the error kind is `UpdateFileSystemProtectionError::TooManyRequests`.
420    pub fn is_too_many_requests(&self) -> bool {
421        matches!(self, Self::TooManyRequests(_))
422    }
423}
424impl ::std::error::Error for UpdateFileSystemProtectionError {
425    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
426        match self {
427            Self::BadRequest(_inner) => ::std::option::Option::Some(_inner),
428            Self::FileSystemNotFound(_inner) => ::std::option::Option::Some(_inner),
429            Self::IncorrectFileSystemLifeCycleState(_inner) => ::std::option::Option::Some(_inner),
430            Self::InsufficientThroughputCapacity(_inner) => ::std::option::Option::Some(_inner),
431            Self::InternalServerError(_inner) => ::std::option::Option::Some(_inner),
432            Self::ReplicationAlreadyExists(_inner) => ::std::option::Option::Some(_inner),
433            Self::ThroughputLimitExceeded(_inner) => ::std::option::Option::Some(_inner),
434            Self::TooManyRequests(_inner) => ::std::option::Option::Some(_inner),
435            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
436        }
437    }
438}
439impl ::std::fmt::Display for UpdateFileSystemProtectionError {
440    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
441        match self {
442            Self::BadRequest(_inner) => _inner.fmt(f),
443            Self::FileSystemNotFound(_inner) => _inner.fmt(f),
444            Self::IncorrectFileSystemLifeCycleState(_inner) => _inner.fmt(f),
445            Self::InsufficientThroughputCapacity(_inner) => _inner.fmt(f),
446            Self::InternalServerError(_inner) => _inner.fmt(f),
447            Self::ReplicationAlreadyExists(_inner) => _inner.fmt(f),
448            Self::ThroughputLimitExceeded(_inner) => _inner.fmt(f),
449            Self::TooManyRequests(_inner) => _inner.fmt(f),
450            Self::Unhandled(_inner) => {
451                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
452                    write!(f, "unhandled error ({code})")
453                } else {
454                    f.write_str("unhandled error")
455                }
456            }
457        }
458    }
459}
460impl ::aws_smithy_types::retry::ProvideErrorKind for UpdateFileSystemProtectionError {
461    fn code(&self) -> ::std::option::Option<&str> {
462        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
463    }
464    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
465        ::std::option::Option::None
466    }
467}
468impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for UpdateFileSystemProtectionError {
469    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
470        match self {
471            Self::BadRequest(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
472            Self::FileSystemNotFound(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
473            Self::IncorrectFileSystemLifeCycleState(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
474            Self::InsufficientThroughputCapacity(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
475            Self::InternalServerError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
476            Self::ReplicationAlreadyExists(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
477            Self::ThroughputLimitExceeded(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
478            Self::TooManyRequests(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
479            Self::Unhandled(_inner) => &_inner.meta,
480        }
481    }
482}
483impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for UpdateFileSystemProtectionError {
484    fn create_unhandled_error(
485        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
486        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
487    ) -> Self {
488        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
489            source,
490            meta: meta.unwrap_or_default(),
491        })
492    }
493}
494impl ::aws_types::request_id::RequestId for crate::operation::update_file_system_protection::UpdateFileSystemProtectionError {
495    fn request_id(&self) -> Option<&str> {
496        self.meta().request_id()
497    }
498}
499
500pub use crate::operation::update_file_system_protection::_update_file_system_protection_input::UpdateFileSystemProtectionInput;
501
502pub use crate::operation::update_file_system_protection::_update_file_system_protection_output::UpdateFileSystemProtectionOutput;
503
504mod _update_file_system_protection_input;
505
506mod _update_file_system_protection_output;
507
508/// Builders
509pub mod builders;