Skip to main content

aws_sdk_pcs/operation/
update_queue.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `UpdateQueue`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct UpdateQueue;
6impl UpdateQueue {
7    /// Creates a new `UpdateQueue`
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_queue::UpdateQueueInput,
14    ) -> ::std::result::Result<
15        crate::operation::update_queue::UpdateQueueOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::update_queue::UpdateQueueError,
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_queue::UpdateQueueError>()
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_queue::UpdateQueueOutput>()
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_queue::UpdateQueueInput,
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("PCS", "UpdateQueue", 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                "PCS.UpdateQueue",
59                "rpc.service" = "PCS",
60                "rpc.method" = "UpdateQueue",
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        runtime_plugins = runtime_plugins.with_operation_plugin(crate::client_idempotency_token::IdempotencyTokenRuntimePlugin::new(
74            |token_provider, input| {
75                let input: &mut crate::operation::update_queue::UpdateQueueInput = input.downcast_mut().expect("correct type");
76                if input.client_token.is_none() {
77                    input.client_token = ::std::option::Option::Some(token_provider.make_idempotency_token());
78                }
79            },
80        ));
81        if let ::std::option::Option::Some(config_override) = config_override {
82            for plugin in config_override.runtime_plugins.iter().cloned() {
83                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
84            }
85            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
86                config_override,
87                client_config.config.clone(),
88                &client_config.runtime_components,
89            ));
90        }
91        runtime_plugins
92    }
93}
94impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for UpdateQueue {
95    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
96        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("UpdateQueue");
97
98        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
99            UpdateQueueRequestSerializer,
100        ));
101        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
102            UpdateQueueResponseDeserializer,
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
106            crate::config::auth::Params::builder()
107                .operation_name("UpdateQueue")
108                .build()
109                .expect("required fields set"),
110        ));
111
112        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("UpdateQueue", "PCS"));
113        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
114        signing_options.double_uri_encode = true;
115        signing_options.content_sha256_header = false;
116        signing_options.normalize_uri_path = true;
117        signing_options.payload_override = None;
118
119        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
120            signing_options,
121            ..::std::default::Default::default()
122        });
123
124        ::std::option::Option::Some(cfg.freeze())
125    }
126
127    fn runtime_components(
128        &self,
129        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
130    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
131        #[allow(unused_mut)]
132        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("UpdateQueue")
133            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
134                UpdateQueueTelemetryInputCaptureInterceptor,
135            ))
136            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
137                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
138            ))
139            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
140                UpdateQueueEndpointParamsInterceptor,
141            ))
142            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
143                crate::operation::update_queue::UpdateQueueError,
144            >::new())
145            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
146                crate::operation::update_queue::UpdateQueueError,
147            >::new())
148            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
149                crate::operation::update_queue::UpdateQueueError,
150            >::new());
151
152        ::std::borrow::Cow::Owned(rcb)
153    }
154}
155
156#[derive(Debug)]
157struct UpdateQueueTelemetryInputCaptureInterceptor;
158
159#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
160impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateQueueTelemetryInputCaptureInterceptor {
161    fn name(&self) -> &'static str {
162        "UpdateQueueTelemetryInputCaptureInterceptor"
163    }
164
165    fn read_before_execution(
166        &self,
167        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
168            '_,
169            ::aws_smithy_runtime_api::client::interceptors::context::Input,
170            ::aws_smithy_runtime_api::client::interceptors::context::Output,
171            ::aws_smithy_runtime_api::client::interceptors::context::Error,
172        >,
173        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
174    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
175        // Nothing to do unless the customer opted in by naming members to record.
176        let ::std::option::Option::Some(requested) = cfg
177            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
178            .filter(|r| !r.is_empty())
179        else {
180            return ::std::result::Result::Ok(());
181        };
182
183        let ::std::option::Option::Some(input) = context.input().downcast_ref::<UpdateQueueInput>() else {
184            // A mismatched input is not this interceptor's concern; skip quietly.
185            return ::std::result::Result::Ok(());
186        };
187
188        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
189        if requested.should_capture("clusterIdentifier") {
190            if let ::std::option::Option::Some(value) = input.cluster_identifier.as_deref() {
191                captured.insert("clusterIdentifier", value);
192            }
193        }
194        if requested.should_capture("queueIdentifier") {
195            if let ::std::option::Option::Some(value) = input.queue_identifier.as_deref() {
196                captured.insert("queueIdentifier", value);
197            }
198        }
199        if requested.should_capture("clientToken") {
200            if let ::std::option::Option::Some(value) = input.client_token.as_deref() {
201                captured.insert("clientToken", value);
202            }
203        }
204
205        cfg.interceptor_state().store_put(captured);
206        ::std::result::Result::Ok(())
207    }
208}
209#[derive(Debug)]
210struct UpdateQueueResponseDeserializer;
211impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for UpdateQueueResponseDeserializer {
212    fn deserialize_nonstreaming_with_config(
213        &self,
214        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
215        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
216    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
217        let (success, status) = (response.status().is_success(), response.status().as_u16());
218        let headers = response.headers();
219        let body = response.body().bytes().expect("body loaded");
220        #[allow(unused_mut)]
221        let mut force_error = false;
222        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
223        let parse_result = if !success && status != 200 || force_error {
224            crate::protocol_serde::shape_update_queue::de_update_queue_http_error(status, headers, body)
225        } else {
226            crate::protocol_serde::shape_update_queue::de_update_queue_http_response(status, headers, body)
227        };
228        crate::protocol_serde::type_erase_result(parse_result)
229    }
230}
231#[derive(Debug)]
232struct UpdateQueueRequestSerializer;
233impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for UpdateQueueRequestSerializer {
234    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
235    fn serialize_input(
236        &self,
237        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
238        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
239    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
240        let input = input
241            .downcast::<crate::operation::update_queue::UpdateQueueInput>()
242            .expect("correct type");
243        let _header_serialization_settings = _cfg
244            .load::<crate::serialization_settings::HeaderSerializationSettings>()
245            .cloned()
246            .unwrap_or_default();
247        let mut request_builder = {
248            #[allow(clippy::uninlined_format_args)]
249            fn uri_base(
250                _input: &crate::operation::update_queue::UpdateQueueInput,
251                output: &mut ::std::string::String,
252            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
253                use ::std::fmt::Write as _;
254                ::std::write!(output, "/").expect("formatting should succeed");
255                ::std::result::Result::Ok(())
256            }
257            #[allow(clippy::unnecessary_wraps)]
258            fn update_http_builder(
259                input: &crate::operation::update_queue::UpdateQueueInput,
260                builder: ::http_1x::request::Builder,
261            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
262                let mut uri = ::std::string::String::new();
263                uri_base(input, &mut uri)?;
264                ::std::result::Result::Ok(builder.method("POST").uri(uri))
265            }
266            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
267            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.0");
268            builder = _header_serialization_settings.set_default_header(
269                builder,
270                ::http_1x::header::HeaderName::from_static("x-amz-target"),
271                "AWSParallelComputingService.UpdateQueue",
272            );
273            builder
274        };
275        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_update_queue::ser_update_queue_input(&input)?);
276        if let Some(content_length) = body.content_length() {
277            let content_length = content_length.to_string();
278            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
279        }
280        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
281    }
282}
283#[derive(Debug)]
284struct UpdateQueueEndpointParamsInterceptor;
285
286#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
287impl ::aws_smithy_runtime_api::client::interceptors::Intercept for UpdateQueueEndpointParamsInterceptor {
288    fn name(&self) -> &'static str {
289        "UpdateQueueEndpointParamsInterceptor"
290    }
291
292    fn read_before_execution(
293        &self,
294        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
295            '_,
296            ::aws_smithy_runtime_api::client::interceptors::context::Input,
297            ::aws_smithy_runtime_api::client::interceptors::context::Output,
298            ::aws_smithy_runtime_api::client::interceptors::context::Error,
299        >,
300        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
301    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
302        let _input = context
303            .input()
304            .downcast_ref::<UpdateQueueInput>()
305            .ok_or("failed to downcast to UpdateQueueInput")?;
306
307        let params = crate::config::endpoint::Params::builder()
308            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
309            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
310            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
311            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
312            .build()
313            .map_err(|err| {
314                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
315            })?;
316        cfg.interceptor_state()
317            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
318        ::std::result::Result::Ok(())
319    }
320}
321
322// The get_* functions below are generated from JMESPath expressions in the
323// operationContextParams trait. They target the operation's input shape.
324
325/// Error type for the `UpdateQueueError` operation.
326#[non_exhaustive]
327#[derive(::std::fmt::Debug)]
328pub enum UpdateQueueError {
329    /// <p>You don't have permission to perform the action.</p>
330    /// <p><u>Examples</u></p>
331    /// <ul>
332    /// <li>
333    /// <p>The launch template instance profile doesn't pass <code>iam:PassRole</code> verification.</p></li>
334    /// <li>
335    /// <p>There is a mismatch between the account ID and cluster ID.</p></li>
336    /// <li>
337    /// <p>The cluster ID doesn't exist.</p></li>
338    /// <li>
339    /// <p>The EC2 instance isn't present.</p></li>
340    /// </ul>
341    AccessDeniedException(crate::types::error::AccessDeniedException),
342    /// <p>Your request has conflicting operations. This can occur if you're trying to perform more than 1 operation on the same resource at the same time.</p>
343    /// <p><u>Examples</u></p>
344    /// <ul>
345    /// <li>
346    /// <p>A cluster with the same name already exists.</p></li>
347    /// <li>
348    /// <p>A cluster isn't in <code>ACTIVE</code> status.</p></li>
349    /// <li>
350    /// <p>A cluster to delete is in an unstable state. For example, because it still has <code>ACTIVE</code> node groups or queues.</p></li>
351    /// <li>
352    /// <p>A queue already exists in a cluster.</p></li>
353    /// </ul>
354    ConflictException(crate::types::error::ConflictException),
355    /// <p>PCS can't process your request right now. Try again later.</p>
356    InternalServerException(crate::types::error::InternalServerException),
357    /// <p>The requested resource can't be found. The cluster, node group, or queue you're attempting to get, update, list, or delete doesn't exist.</p>
358    /// <p><u>Examples</u></p>
359    ResourceNotFoundException(crate::types::error::ResourceNotFoundException),
360    /// <p>You exceeded your service quota. Service quotas, also referred to as limits, are the maximum number of service resources or operations for your Amazon Web Services account. To learn how to increase your service quota, see <a href="https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html">Requesting a quota increase</a> in the <i>Service Quotas User Guide</i></p>
361    /// <p><u>Examples</u></p>
362    /// <ul>
363    /// <li>
364    /// <p>The max number of clusters or queues has been reached for the account.</p></li>
365    /// <li>
366    /// <p>The max number of compute node groups has been reached for the associated cluster.</p></li>
367    /// <li>
368    /// <p>The total of <code>maxInstances</code> across all compute node groups has been reached for associated cluster.</p></li>
369    /// </ul>
370    ServiceQuotaExceededException(crate::types::error::ServiceQuotaExceededException),
371    /// <p>Your request exceeded a request rate quota. Check the resource's request rate quota and try again.</p>
372    ThrottlingException(crate::types::error::ThrottlingException),
373    /// <p>The request isn't valid.</p>
374    /// <p><u>Examples</u></p>
375    /// <ul>
376    /// <li>
377    /// <p>Your request contains malformed JSON or unsupported characters.</p></li>
378    /// <li>
379    /// <p>The scheduler version isn't supported.</p></li>
380    /// <li>
381    /// <p>There are networking related errors, such as network validation failure.</p></li>
382    /// <li>
383    /// <p>AMI type is <code>CUSTOM</code> and the launch template doesn't define the AMI ID, or the AMI type is AL2 and the launch template defines the AMI.</p></li>
384    /// </ul>
385    ValidationException(crate::types::error::ValidationException),
386    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
387    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
388    variable wildcard pattern and check `.code()`:
389     \
390    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
391     \
392    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-UpdateQueueError) for what information is available for the error.")]
393    Unhandled(crate::error::sealed_unhandled::Unhandled),
394}
395impl UpdateQueueError {
396    /// Creates the `UpdateQueueError::Unhandled` variant from any error type.
397    pub fn unhandled(
398        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
399    ) -> Self {
400        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
401            source: err.into(),
402            meta: ::std::default::Default::default(),
403        })
404    }
405
406    /// Creates the `UpdateQueueError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
407    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
408        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
409            source: err.clone().into(),
410            meta: err,
411        })
412    }
413    ///
414    /// Returns error metadata, which includes the error code, message,
415    /// request ID, and potentially additional information.
416    ///
417    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
418        match self {
419            Self::AccessDeniedException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
420            Self::ConflictException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
421            Self::InternalServerException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
422            Self::ResourceNotFoundException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
423            Self::ServiceQuotaExceededException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
424            Self::ThrottlingException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
425            Self::ValidationException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
426            Self::Unhandled(e) => &e.meta,
427        }
428    }
429    /// Returns `true` if the error kind is `UpdateQueueError::AccessDeniedException`.
430    pub fn is_access_denied_exception(&self) -> bool {
431        matches!(self, Self::AccessDeniedException(_))
432    }
433    /// Returns `true` if the error kind is `UpdateQueueError::ConflictException`.
434    pub fn is_conflict_exception(&self) -> bool {
435        matches!(self, Self::ConflictException(_))
436    }
437    /// Returns `true` if the error kind is `UpdateQueueError::InternalServerException`.
438    pub fn is_internal_server_exception(&self) -> bool {
439        matches!(self, Self::InternalServerException(_))
440    }
441    /// Returns `true` if the error kind is `UpdateQueueError::ResourceNotFoundException`.
442    pub fn is_resource_not_found_exception(&self) -> bool {
443        matches!(self, Self::ResourceNotFoundException(_))
444    }
445    /// Returns `true` if the error kind is `UpdateQueueError::ServiceQuotaExceededException`.
446    pub fn is_service_quota_exceeded_exception(&self) -> bool {
447        matches!(self, Self::ServiceQuotaExceededException(_))
448    }
449    /// Returns `true` if the error kind is `UpdateQueueError::ThrottlingException`.
450    pub fn is_throttling_exception(&self) -> bool {
451        matches!(self, Self::ThrottlingException(_))
452    }
453    /// Returns `true` if the error kind is `UpdateQueueError::ValidationException`.
454    pub fn is_validation_exception(&self) -> bool {
455        matches!(self, Self::ValidationException(_))
456    }
457}
458impl ::std::error::Error for UpdateQueueError {
459    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
460        match self {
461            Self::AccessDeniedException(_inner) => ::std::option::Option::Some(_inner),
462            Self::ConflictException(_inner) => ::std::option::Option::Some(_inner),
463            Self::InternalServerException(_inner) => ::std::option::Option::Some(_inner),
464            Self::ResourceNotFoundException(_inner) => ::std::option::Option::Some(_inner),
465            Self::ServiceQuotaExceededException(_inner) => ::std::option::Option::Some(_inner),
466            Self::ThrottlingException(_inner) => ::std::option::Option::Some(_inner),
467            Self::ValidationException(_inner) => ::std::option::Option::Some(_inner),
468            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
469        }
470    }
471}
472impl ::std::fmt::Display for UpdateQueueError {
473    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
474        match self {
475            Self::AccessDeniedException(_inner) => _inner.fmt(f),
476            Self::ConflictException(_inner) => _inner.fmt(f),
477            Self::InternalServerException(_inner) => _inner.fmt(f),
478            Self::ResourceNotFoundException(_inner) => _inner.fmt(f),
479            Self::ServiceQuotaExceededException(_inner) => _inner.fmt(f),
480            Self::ThrottlingException(_inner) => _inner.fmt(f),
481            Self::ValidationException(_inner) => _inner.fmt(f),
482            Self::Unhandled(_inner) => {
483                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
484                    write!(f, "unhandled error ({code})")
485                } else {
486                    f.write_str("unhandled error")
487                }
488            }
489        }
490    }
491}
492impl ::aws_smithy_types::retry::ProvideErrorKind for UpdateQueueError {
493    fn code(&self) -> ::std::option::Option<&str> {
494        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
495    }
496    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
497        match self {
498            Self::InternalServerException(inner) => ::std::option::Option::Some(inner.retryable_error_kind()),
499            Self::ThrottlingException(inner) => ::std::option::Option::Some(inner.retryable_error_kind()),
500            _ => ::std::option::Option::None,
501        }
502    }
503}
504impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for UpdateQueueError {
505    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
506        match self {
507            Self::AccessDeniedException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
508            Self::ConflictException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
509            Self::InternalServerException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
510            Self::ResourceNotFoundException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
511            Self::ServiceQuotaExceededException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
512            Self::ThrottlingException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
513            Self::ValidationException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
514            Self::Unhandled(_inner) => &_inner.meta,
515        }
516    }
517}
518impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for UpdateQueueError {
519    fn create_unhandled_error(
520        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
521        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
522    ) -> Self {
523        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
524            source,
525            meta: meta.unwrap_or_default(),
526        })
527    }
528}
529impl ::aws_types::request_id::RequestId for crate::operation::update_queue::UpdateQueueError {
530    fn request_id(&self) -> Option<&str> {
531        self.meta().request_id()
532    }
533}
534
535pub use crate::operation::update_queue::_update_queue_input::UpdateQueueInput;
536
537pub use crate::operation::update_queue::_update_queue_output::UpdateQueueOutput;
538
539mod _update_queue_input;
540
541mod _update_queue_output;
542
543/// Builders
544pub mod builders;