Skip to main content

aws_sdk_devopsguru/operation/
describe_anomaly.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `DescribeAnomaly`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct DescribeAnomaly;
6impl DescribeAnomaly {
7    /// Creates a new `DescribeAnomaly`
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::describe_anomaly::DescribeAnomalyInput,
14    ) -> ::std::result::Result<
15        crate::operation::describe_anomaly::DescribeAnomalyOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::describe_anomaly::DescribeAnomalyError,
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::describe_anomaly::DescribeAnomalyError>()
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::describe_anomaly::DescribeAnomalyOutput>()
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::describe_anomaly::DescribeAnomalyInput,
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("DevOps Guru", "DescribeAnomaly", 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                "DevOps Guru.DescribeAnomaly",
59                "rpc.service" = "DevOps Guru",
60                "rpc.method" = "DescribeAnomaly",
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 DescribeAnomaly {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DescribeAnomaly");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            DescribeAnomalyRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            DescribeAnomalyResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("DescribeAnomaly")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
106            "DescribeAnomaly",
107            "DevOps Guru",
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("DescribeAnomaly")
129            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
130                DescribeAnomalyTelemetryInputCaptureInterceptor,
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                DescribeAnomalyEndpointParamsInterceptor,
137            ))
138            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
139                crate::operation::describe_anomaly::DescribeAnomalyError,
140            >::new())
141            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
142                crate::operation::describe_anomaly::DescribeAnomalyError,
143            >::new())
144            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
145                crate::operation::describe_anomaly::DescribeAnomalyError,
146            >::new());
147
148        ::std::borrow::Cow::Owned(rcb)
149    }
150}
151
152#[derive(Debug)]
153struct DescribeAnomalyTelemetryInputCaptureInterceptor;
154
155#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
156impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DescribeAnomalyTelemetryInputCaptureInterceptor {
157    fn name(&self) -> &'static str {
158        "DescribeAnomalyTelemetryInputCaptureInterceptor"
159    }
160
161    fn read_before_execution(
162        &self,
163        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
164            '_,
165            ::aws_smithy_runtime_api::client::interceptors::context::Input,
166            ::aws_smithy_runtime_api::client::interceptors::context::Output,
167            ::aws_smithy_runtime_api::client::interceptors::context::Error,
168        >,
169        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
170    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
171        // Nothing to do unless the customer opted in by naming members to record.
172        let ::std::option::Option::Some(requested) = cfg
173            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
174            .filter(|r| !r.is_empty())
175        else {
176            return ::std::result::Result::Ok(());
177        };
178
179        let ::std::option::Option::Some(input) = context.input().downcast_ref::<DescribeAnomalyInput>() else {
180            // A mismatched input is not this interceptor's concern; skip quietly.
181            return ::std::result::Result::Ok(());
182        };
183
184        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
185        if requested.should_capture("Id") {
186            if let ::std::option::Option::Some(value) = input.id.as_deref() {
187                captured.insert("Id", value);
188            }
189        }
190        if requested.should_capture("AccountId") {
191            if let ::std::option::Option::Some(value) = input.account_id.as_deref() {
192                captured.insert("AccountId", value);
193            }
194        }
195
196        cfg.interceptor_state().store_put(captured);
197        ::std::result::Result::Ok(())
198    }
199}
200#[derive(Debug)]
201struct DescribeAnomalyResponseDeserializer;
202impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DescribeAnomalyResponseDeserializer {
203    fn deserialize_nonstreaming_with_config(
204        &self,
205        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
206        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
207    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
208        let (success, status) = (response.status().is_success(), response.status().as_u16());
209        let headers = response.headers();
210        let body = response.body().bytes().expect("body loaded");
211        #[allow(unused_mut)]
212        let mut force_error = false;
213        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
214        let parse_result = if !success && status != 200 || force_error {
215            crate::protocol_serde::shape_describe_anomaly::de_describe_anomaly_http_error(status, headers, body)
216        } else {
217            crate::protocol_serde::shape_describe_anomaly::de_describe_anomaly_http_response(status, headers, body)
218        };
219        crate::protocol_serde::type_erase_result(parse_result)
220    }
221}
222#[derive(Debug)]
223struct DescribeAnomalyRequestSerializer;
224impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DescribeAnomalyRequestSerializer {
225    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
226    fn serialize_input(
227        &self,
228        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
229        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
230    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
231        let input = input
232            .downcast::<crate::operation::describe_anomaly::DescribeAnomalyInput>()
233            .expect("correct type");
234        let _header_serialization_settings = _cfg
235            .load::<crate::serialization_settings::HeaderSerializationSettings>()
236            .cloned()
237            .unwrap_or_default();
238        let mut request_builder = {
239            #[allow(clippy::uninlined_format_args)]
240            fn uri_base(
241                _input: &crate::operation::describe_anomaly::DescribeAnomalyInput,
242                output: &mut ::std::string::String,
243            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
244                use ::std::fmt::Write as _;
245                let input_1 = &_input.id;
246                let input_1 = input_1
247                    .as_ref()
248                    .ok_or_else(|| ::aws_smithy_types::error::operation::BuildError::missing_field("id", "cannot be empty or unset"))?;
249                let id = ::aws_smithy_http::label::fmt_string(input_1, ::aws_smithy_http::label::EncodingStrategy::Default);
250                if id.is_empty() {
251                    return ::std::result::Result::Err(::aws_smithy_types::error::operation::BuildError::missing_field(
252                        "id",
253                        "cannot be empty or unset",
254                    ));
255                }
256                ::std::write!(output, "/anomalies/{Id}", Id = id).expect("formatting should succeed");
257                ::std::result::Result::Ok(())
258            }
259            fn uri_query(
260                _input: &crate::operation::describe_anomaly::DescribeAnomalyInput,
261                mut output: &mut ::std::string::String,
262            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
263                let mut query = ::aws_smithy_http::query::Writer::new(output);
264                if let ::std::option::Option::Some(inner_2) = &_input.account_id {
265                    {
266                        query.push_kv("AccountId", &::aws_smithy_http::query::fmt_string(inner_2));
267                    }
268                }
269                ::std::result::Result::Ok(())
270            }
271            #[allow(clippy::unnecessary_wraps)]
272            fn update_http_builder(
273                input: &crate::operation::describe_anomaly::DescribeAnomalyInput,
274                builder: ::http_1x::request::Builder,
275            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
276                let mut uri = ::std::string::String::new();
277                uri_base(input, &mut uri)?;
278                uri_query(input, &mut uri)?;
279                ::std::result::Result::Ok(builder.method("GET").uri(uri))
280            }
281            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
282            builder
283        };
284        let body = ::aws_smithy_types::body::SdkBody::from("");
285
286        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
287    }
288}
289#[derive(Debug)]
290struct DescribeAnomalyEndpointParamsInterceptor;
291
292#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
293impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DescribeAnomalyEndpointParamsInterceptor {
294    fn name(&self) -> &'static str {
295        "DescribeAnomalyEndpointParamsInterceptor"
296    }
297
298    fn read_before_execution(
299        &self,
300        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
301            '_,
302            ::aws_smithy_runtime_api::client::interceptors::context::Input,
303            ::aws_smithy_runtime_api::client::interceptors::context::Output,
304            ::aws_smithy_runtime_api::client::interceptors::context::Error,
305        >,
306        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
307    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
308        let _input = context
309            .input()
310            .downcast_ref::<DescribeAnomalyInput>()
311            .ok_or("failed to downcast to DescribeAnomalyInput")?;
312
313        let params = crate::config::endpoint::Params::builder()
314            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
315            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
316            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
317            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
318            .build()
319            .map_err(|err| {
320                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
321            })?;
322        cfg.interceptor_state()
323            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
324        ::std::result::Result::Ok(())
325    }
326}
327
328// The get_* functions below are generated from JMESPath expressions in the
329// operationContextParams trait. They target the operation's input shape.
330
331/// Error type for the `DescribeAnomalyError` operation.
332#[non_exhaustive]
333#[derive(::std::fmt::Debug)]
334pub enum DescribeAnomalyError {
335    /// <p>You don't have permissions to perform the requested operation. The user or role that is making the request must have at least one IAM permissions policy attached that grants the required permissions. For more information, see <a href="https://docs.aws.amazon.com/IAM/latest/UserGuide/access.html">Access Management</a> in the <i>IAM User Guide</i>.</p>
336    AccessDeniedException(crate::types::error::AccessDeniedException),
337    /// <p>An internal failure in an Amazon service occurred.</p>
338    InternalServerException(crate::types::error::InternalServerException),
339    /// <p>A requested resource could not be found</p>
340    ResourceNotFoundException(crate::types::error::ResourceNotFoundException),
341    /// <p>The request was denied due to a request throttling.</p>
342    ThrottlingException(crate::types::error::ThrottlingException),
343    /// <p>Contains information about data passed in to a field during a request that is not valid.</p>
344    ValidationException(crate::types::error::ValidationException),
345    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
346    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
347    variable wildcard pattern and check `.code()`:
348     \
349    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
350     \
351    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-DescribeAnomalyError) for what information is available for the error.")]
352    Unhandled(crate::error::sealed_unhandled::Unhandled),
353}
354impl DescribeAnomalyError {
355    /// Creates the `DescribeAnomalyError::Unhandled` variant from any error type.
356    pub fn unhandled(
357        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
358    ) -> Self {
359        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
360            source: err.into(),
361            meta: ::std::default::Default::default(),
362        })
363    }
364
365    /// Creates the `DescribeAnomalyError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
366    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
367        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
368            source: err.clone().into(),
369            meta: err,
370        })
371    }
372    ///
373    /// Returns error metadata, which includes the error code, message,
374    /// request ID, and potentially additional information.
375    ///
376    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
377        match self {
378            Self::AccessDeniedException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
379            Self::InternalServerException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
380            Self::ResourceNotFoundException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
381            Self::ThrottlingException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
382            Self::ValidationException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
383            Self::Unhandled(e) => &e.meta,
384        }
385    }
386    /// Returns `true` if the error kind is `DescribeAnomalyError::AccessDeniedException`.
387    pub fn is_access_denied_exception(&self) -> bool {
388        matches!(self, Self::AccessDeniedException(_))
389    }
390    /// Returns `true` if the error kind is `DescribeAnomalyError::InternalServerException`.
391    pub fn is_internal_server_exception(&self) -> bool {
392        matches!(self, Self::InternalServerException(_))
393    }
394    /// Returns `true` if the error kind is `DescribeAnomalyError::ResourceNotFoundException`.
395    pub fn is_resource_not_found_exception(&self) -> bool {
396        matches!(self, Self::ResourceNotFoundException(_))
397    }
398    /// Returns `true` if the error kind is `DescribeAnomalyError::ThrottlingException`.
399    pub fn is_throttling_exception(&self) -> bool {
400        matches!(self, Self::ThrottlingException(_))
401    }
402    /// Returns `true` if the error kind is `DescribeAnomalyError::ValidationException`.
403    pub fn is_validation_exception(&self) -> bool {
404        matches!(self, Self::ValidationException(_))
405    }
406}
407impl ::std::error::Error for DescribeAnomalyError {
408    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
409        match self {
410            Self::AccessDeniedException(_inner) => ::std::option::Option::Some(_inner),
411            Self::InternalServerException(_inner) => ::std::option::Option::Some(_inner),
412            Self::ResourceNotFoundException(_inner) => ::std::option::Option::Some(_inner),
413            Self::ThrottlingException(_inner) => ::std::option::Option::Some(_inner),
414            Self::ValidationException(_inner) => ::std::option::Option::Some(_inner),
415            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
416        }
417    }
418}
419impl ::std::fmt::Display for DescribeAnomalyError {
420    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
421        match self {
422            Self::AccessDeniedException(_inner) => _inner.fmt(f),
423            Self::InternalServerException(_inner) => _inner.fmt(f),
424            Self::ResourceNotFoundException(_inner) => _inner.fmt(f),
425            Self::ThrottlingException(_inner) => _inner.fmt(f),
426            Self::ValidationException(_inner) => _inner.fmt(f),
427            Self::Unhandled(_inner) => {
428                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
429                    write!(f, "unhandled error ({code})")
430                } else {
431                    f.write_str("unhandled error")
432                }
433            }
434        }
435    }
436}
437impl ::aws_smithy_types::retry::ProvideErrorKind for DescribeAnomalyError {
438    fn code(&self) -> ::std::option::Option<&str> {
439        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
440    }
441    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
442        ::std::option::Option::None
443    }
444}
445impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for DescribeAnomalyError {
446    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
447        match self {
448            Self::AccessDeniedException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
449            Self::InternalServerException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
450            Self::ResourceNotFoundException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
451            Self::ThrottlingException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
452            Self::ValidationException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
453            Self::Unhandled(_inner) => &_inner.meta,
454        }
455    }
456}
457impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for DescribeAnomalyError {
458    fn create_unhandled_error(
459        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
460        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
461    ) -> Self {
462        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
463            source,
464            meta: meta.unwrap_or_default(),
465        })
466    }
467}
468impl ::aws_types::request_id::RequestId for crate::operation::describe_anomaly::DescribeAnomalyError {
469    fn request_id(&self) -> Option<&str> {
470        self.meta().request_id()
471    }
472}
473
474pub use crate::operation::describe_anomaly::_describe_anomaly_input::DescribeAnomalyInput;
475
476pub use crate::operation::describe_anomaly::_describe_anomaly_output::DescribeAnomalyOutput;
477
478mod _describe_anomaly_input;
479
480mod _describe_anomaly_output;
481
482/// Builders
483pub mod builders;