Skip to main content

aws_sdk_kms/operation/
verify_mac.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `VerifyMac`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct VerifyMac;
6impl VerifyMac {
7    /// Creates a new `VerifyMac`
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::verify_mac::VerifyMacInput,
14    ) -> ::std::result::Result<
15        crate::operation::verify_mac::VerifyMacOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::verify_mac::VerifyMacError,
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::verify_mac::VerifyMacError>()
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::verify_mac::VerifyMacOutput>()
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::verify_mac::VerifyMacInput,
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("KMS", "VerifyMac", 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                "KMS.VerifyMac",
59                "rpc.service" = "KMS",
60                "rpc.method" = "VerifyMac",
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 VerifyMac {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("VerifyMac");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            VerifyMacRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            VerifyMacResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("VerifyMac")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("VerifyMac", "KMS"));
106        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
107        signing_options.double_uri_encode = true;
108        signing_options.content_sha256_header = false;
109        signing_options.normalize_uri_path = true;
110        signing_options.payload_override = None;
111
112        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
113            signing_options,
114            ..::std::default::Default::default()
115        });
116
117        ::std::option::Option::Some(cfg.freeze())
118    }
119
120    fn runtime_components(
121        &self,
122        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
123    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
124        #[allow(unused_mut)]
125        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("VerifyMac")
126            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
127                VerifyMacTelemetryInputCaptureInterceptor,
128            ))
129            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
130                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
131            ))
132            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
133                VerifyMacEndpointParamsInterceptor,
134            ))
135            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
136                crate::operation::verify_mac::VerifyMacError,
137            >::new())
138            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
139                crate::operation::verify_mac::VerifyMacError,
140            >::new())
141            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
142                crate::operation::verify_mac::VerifyMacError,
143            >::new())
144            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
145                crate::operation::verify_mac::VerifyMacError,
146            >::new());
147
148        ::std::borrow::Cow::Owned(rcb)
149    }
150}
151
152#[derive(Debug)]
153struct VerifyMacTelemetryInputCaptureInterceptor;
154
155#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
156impl ::aws_smithy_runtime_api::client::interceptors::Intercept for VerifyMacTelemetryInputCaptureInterceptor {
157    fn name(&self) -> &'static str {
158        "VerifyMacTelemetryInputCaptureInterceptor"
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::<VerifyMacInput>() 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("KeyId") {
186            if let ::std::option::Option::Some(value) = input.key_id.as_deref() {
187                captured.insert("KeyId", value);
188            }
189        }
190
191        cfg.interceptor_state().store_put(captured);
192        ::std::result::Result::Ok(())
193    }
194}
195#[derive(Debug)]
196struct VerifyMacResponseDeserializer;
197impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for VerifyMacResponseDeserializer {
198    fn deserialize_nonstreaming_with_config(
199        &self,
200        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
201        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
202    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
203        let (success, status) = (response.status().is_success(), response.status().as_u16());
204        let headers = response.headers();
205        let body = response.body().bytes().expect("body loaded");
206        #[allow(unused_mut)]
207        let mut force_error = false;
208        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
209        let parse_result = if !success && status != 200 || force_error {
210            crate::protocol_serde::shape_verify_mac::de_verify_mac_http_error(status, headers, body, _cfg)
211        } else {
212            crate::protocol_serde::shape_verify_mac::de_verify_mac_http_response(status, headers, body, _cfg)
213        };
214        crate::protocol_serde::type_erase_result(parse_result)
215    }
216}
217#[derive(Debug)]
218struct VerifyMacRequestSerializer;
219impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for VerifyMacRequestSerializer {
220    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
221    fn serialize_input(
222        &self,
223        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
224        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
225    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
226        let input = input.downcast::<crate::operation::verify_mac::VerifyMacInput>().expect("correct type");
227        let _header_serialization_settings = _cfg
228            .load::<crate::serialization_settings::HeaderSerializationSettings>()
229            .cloned()
230            .unwrap_or_default();
231        let mut request_builder = {
232            #[allow(clippy::uninlined_format_args)]
233            fn uri_base(
234                _input: &crate::operation::verify_mac::VerifyMacInput,
235                output: &mut ::std::string::String,
236            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
237                use ::std::fmt::Write as _;
238                ::std::write!(output, "/").expect("formatting should succeed");
239                ::std::result::Result::Ok(())
240            }
241            #[allow(clippy::unnecessary_wraps)]
242            fn update_http_builder(
243                input: &crate::operation::verify_mac::VerifyMacInput,
244                builder: ::http_1x::request::Builder,
245            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
246                let mut uri = ::std::string::String::new();
247                uri_base(input, &mut uri)?;
248                ::std::result::Result::Ok(builder.method("POST").uri(uri))
249            }
250            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
251            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
252            builder = _header_serialization_settings.set_default_header(
253                builder,
254                ::http_1x::header::HeaderName::from_static("x-amz-target"),
255                "TrentService.VerifyMac",
256            );
257            builder
258        };
259        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_verify_mac::ser_verify_mac_input(&input)?);
260        if let Some(content_length) = body.content_length() {
261            let content_length = content_length.to_string();
262            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
263        }
264        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
265    }
266}
267#[derive(Debug)]
268struct VerifyMacEndpointParamsInterceptor;
269
270#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
271impl ::aws_smithy_runtime_api::client::interceptors::Intercept for VerifyMacEndpointParamsInterceptor {
272    fn name(&self) -> &'static str {
273        "VerifyMacEndpointParamsInterceptor"
274    }
275
276    fn read_before_execution(
277        &self,
278        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
279            '_,
280            ::aws_smithy_runtime_api::client::interceptors::context::Input,
281            ::aws_smithy_runtime_api::client::interceptors::context::Output,
282            ::aws_smithy_runtime_api::client::interceptors::context::Error,
283        >,
284        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
285    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
286        let _input = context
287            .input()
288            .downcast_ref::<VerifyMacInput>()
289            .ok_or("failed to downcast to VerifyMacInput")?;
290
291        let params = crate::config::endpoint::Params::builder()
292            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
293            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
294            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
295            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
296            .build()
297            .map_err(|err| {
298                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
299            })?;
300        cfg.interceptor_state()
301            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
302        ::std::result::Result::Ok(())
303    }
304}
305
306// The get_* functions below are generated from JMESPath expressions in the
307// operationContextParams trait. They target the operation's input shape.
308
309/// Error type for the `VerifyMacError` operation.
310#[non_exhaustive]
311#[derive(::std::fmt::Debug)]
312pub enum VerifyMacError {
313    /// <p>The request was rejected because the specified KMS key is not enabled.</p>
314    DisabledException(crate::types::error::DisabledException),
315    /// <p>The request was rejected because the DryRun parameter was specified.</p>
316    DryRunOperationException(crate::types::error::DryRunOperationException),
317    /// <p>The request was rejected because the specified grant token is not valid.</p>
318    InvalidGrantTokenException(crate::types::error::InvalidGrantTokenException),
319    /// <p>The request was rejected for one of the following reasons:</p>
320    /// <ul>
321    /// <li>
322    /// <p>The <code>KeyUsage</code> value of the KMS key is incompatible with the API operation.</p></li>
323    /// <li>
324    /// <p>The encryption algorithm or signing algorithm specified for the operation is incompatible with the type of key material in the KMS key <code>(KeySpec</code>).</p></li>
325    /// </ul>
326    /// <p>For encrypting, decrypting, re-encrypting, and generating data keys, the <code>KeyUsage</code> must be <code>ENCRYPT_DECRYPT</code>. For signing and verifying messages, the <code>KeyUsage</code> must be <code>SIGN_VERIFY</code>. For generating and verifying message authentication codes (MACs), the <code>KeyUsage</code> must be <code>GENERATE_VERIFY_MAC</code>. For deriving key agreement secrets, the <code>KeyUsage</code> must be <code>KEY_AGREEMENT</code>. To find the <code>KeyUsage</code> of a KMS key, use the <code>DescribeKey</code> operation.</p>
327    /// <p>To find the encryption or signing algorithms supported for a particular KMS key, use the <code>DescribeKey</code> operation.</p>
328    InvalidKeyUsageException(crate::types::error::InvalidKeyUsageException),
329    /// <p>The request was rejected because the specified KMS key was not available. You can retry the request.</p>
330    KeyUnavailableException(crate::types::error::KeyUnavailableException),
331    /// <p>The request was rejected because an internal exception occurred. The request can be retried.</p>
332    KmsInternalException(crate::types::error::KmsInternalException),
333    /// <p>The request was rejected because the HMAC verification failed. HMAC verification fails when the HMAC computed by using the specified message, HMAC KMS key, and MAC algorithm does not match the HMAC specified in the request.</p>
334    KmsInvalidMacException(crate::types::error::KmsInvalidMacException),
335    /// <p>The request was rejected because the state of the specified resource is not valid for this request.</p>
336    /// <p>This exceptions means one of the following:</p>
337    /// <ul>
338    /// <li>
339    /// <p>The key state of the KMS key is not compatible with the operation.</p>
340    /// <p>To find the key state, use the <code>DescribeKey</code> operation. For more information about which key states are compatible with each KMS operation, see <a href="https://docs.aws.amazon.com/kms/latest/developerguide/key-state.html">Key states of KMS keys</a> in the <i> <i>Key Management Service Developer Guide</i> </i>.</p></li>
341    /// <li>
342    /// <p>For cryptographic operations on KMS keys in custom key stores, this exception represents a general failure with many possible causes. To identify the cause, see the error message that accompanies the exception.</p></li>
343    /// </ul>
344    KmsInvalidStateException(crate::types::error::KmsInvalidStateException),
345    /// <p>The request was rejected because the specified entity or resource could not be found.</p>
346    NotFoundException(crate::types::error::NotFoundException),
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-VerifyMacError) for what information is available for the error.")]
354    Unhandled(crate::error::sealed_unhandled::Unhandled),
355}
356impl VerifyMacError {
357    /// Creates the `VerifyMacError::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 `VerifyMacError::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::DisabledException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
381            Self::DryRunOperationException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
382            Self::InvalidGrantTokenException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
383            Self::InvalidKeyUsageException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
384            Self::KeyUnavailableException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
385            Self::KmsInternalException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
386            Self::KmsInvalidMacException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
387            Self::KmsInvalidStateException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
388            Self::NotFoundException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
389            Self::Unhandled(e) => &e.meta,
390        }
391    }
392    /// Returns `true` if the error kind is `VerifyMacError::DisabledException`.
393    pub fn is_disabled_exception(&self) -> bool {
394        matches!(self, Self::DisabledException(_))
395    }
396    /// Returns `true` if the error kind is `VerifyMacError::DryRunOperationException`.
397    pub fn is_dry_run_operation_exception(&self) -> bool {
398        matches!(self, Self::DryRunOperationException(_))
399    }
400    /// Returns `true` if the error kind is `VerifyMacError::InvalidGrantTokenException`.
401    pub fn is_invalid_grant_token_exception(&self) -> bool {
402        matches!(self, Self::InvalidGrantTokenException(_))
403    }
404    /// Returns `true` if the error kind is `VerifyMacError::InvalidKeyUsageException`.
405    pub fn is_invalid_key_usage_exception(&self) -> bool {
406        matches!(self, Self::InvalidKeyUsageException(_))
407    }
408    /// Returns `true` if the error kind is `VerifyMacError::KeyUnavailableException`.
409    pub fn is_key_unavailable_exception(&self) -> bool {
410        matches!(self, Self::KeyUnavailableException(_))
411    }
412    /// Returns `true` if the error kind is `VerifyMacError::KmsInternalException`.
413    pub fn is_kms_internal_exception(&self) -> bool {
414        matches!(self, Self::KmsInternalException(_))
415    }
416    /// Returns `true` if the error kind is `VerifyMacError::KmsInvalidMacException`.
417    pub fn is_kms_invalid_mac_exception(&self) -> bool {
418        matches!(self, Self::KmsInvalidMacException(_))
419    }
420    /// Returns `true` if the error kind is `VerifyMacError::KmsInvalidStateException`.
421    pub fn is_kms_invalid_state_exception(&self) -> bool {
422        matches!(self, Self::KmsInvalidStateException(_))
423    }
424    /// Returns `true` if the error kind is `VerifyMacError::NotFoundException`.
425    pub fn is_not_found_exception(&self) -> bool {
426        matches!(self, Self::NotFoundException(_))
427    }
428}
429impl ::std::error::Error for VerifyMacError {
430    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
431        match self {
432            Self::DisabledException(_inner) => ::std::option::Option::Some(_inner),
433            Self::DryRunOperationException(_inner) => ::std::option::Option::Some(_inner),
434            Self::InvalidGrantTokenException(_inner) => ::std::option::Option::Some(_inner),
435            Self::InvalidKeyUsageException(_inner) => ::std::option::Option::Some(_inner),
436            Self::KeyUnavailableException(_inner) => ::std::option::Option::Some(_inner),
437            Self::KmsInternalException(_inner) => ::std::option::Option::Some(_inner),
438            Self::KmsInvalidMacException(_inner) => ::std::option::Option::Some(_inner),
439            Self::KmsInvalidStateException(_inner) => ::std::option::Option::Some(_inner),
440            Self::NotFoundException(_inner) => ::std::option::Option::Some(_inner),
441            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
442        }
443    }
444}
445impl ::std::fmt::Display for VerifyMacError {
446    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
447        match self {
448            Self::DisabledException(_inner) => _inner.fmt(f),
449            Self::DryRunOperationException(_inner) => _inner.fmt(f),
450            Self::InvalidGrantTokenException(_inner) => _inner.fmt(f),
451            Self::InvalidKeyUsageException(_inner) => _inner.fmt(f),
452            Self::KeyUnavailableException(_inner) => _inner.fmt(f),
453            Self::KmsInternalException(_inner) => _inner.fmt(f),
454            Self::KmsInvalidMacException(_inner) => _inner.fmt(f),
455            Self::KmsInvalidStateException(_inner) => _inner.fmt(f),
456            Self::NotFoundException(_inner) => _inner.fmt(f),
457            Self::Unhandled(_inner) => {
458                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
459                    write!(f, "unhandled error ({code})")
460                } else {
461                    f.write_str("unhandled error")
462                }
463            }
464        }
465    }
466}
467impl ::aws_smithy_types::retry::ProvideErrorKind for VerifyMacError {
468    fn code(&self) -> ::std::option::Option<&str> {
469        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
470    }
471    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
472        ::std::option::Option::None
473    }
474}
475impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for VerifyMacError {
476    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
477        match self {
478            Self::DisabledException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
479            Self::DryRunOperationException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
480            Self::InvalidGrantTokenException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
481            Self::InvalidKeyUsageException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
482            Self::KeyUnavailableException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
483            Self::KmsInternalException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
484            Self::KmsInvalidMacException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
485            Self::KmsInvalidStateException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
486            Self::NotFoundException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
487            Self::Unhandled(_inner) => &_inner.meta,
488        }
489    }
490}
491impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for VerifyMacError {
492    fn create_unhandled_error(
493        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
494        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
495    ) -> Self {
496        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
497            source,
498            meta: meta.unwrap_or_default(),
499        })
500    }
501}
502impl ::aws_types::request_id::RequestId for crate::operation::verify_mac::VerifyMacError {
503    fn request_id(&self) -> Option<&str> {
504        self.meta().request_id()
505    }
506}
507
508pub use crate::operation::verify_mac::_verify_mac_input::VerifyMacInput;
509
510pub use crate::operation::verify_mac::_verify_mac_output::VerifyMacOutput;
511
512mod _verify_mac_input;
513
514mod _verify_mac_output;
515
516/// Builders
517pub mod builders;