Skip to main content

aws_sdk_ssm/operation/
send_command.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2/// Orchestration and serialization glue logic for `SendCommand`.
3#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
4#[non_exhaustive]
5pub struct SendCommand;
6impl SendCommand {
7    /// Creates a new `SendCommand`
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::send_command::SendCommandInput,
14    ) -> ::std::result::Result<
15        crate::operation::send_command::SendCommandOutput,
16        ::aws_smithy_runtime_api::client::result::SdkError<
17            crate::operation::send_command::SendCommandError,
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::send_command::SendCommandError>()
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::send_command::SendCommandOutput>()
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::send_command::SendCommandInput,
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("SSM", "SendCommand", 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                "SSM.SendCommand",
59                "rpc.service" = "SSM",
60                "rpc.method" = "SendCommand",
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 SendCommand {
88    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
89        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("SendCommand");
90
91        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
92            SendCommandRequestSerializer,
93        ));
94        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
95            SendCommandResponseDeserializer,
96        ));
97
98        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
99            crate::config::auth::Params::builder()
100                .operation_name("SendCommand")
101                .build()
102                .expect("required fields set"),
103        ));
104
105        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::SensitiveOutput);
106        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("SendCommand", "SSM"));
107        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
108        signing_options.double_uri_encode = true;
109        signing_options.content_sha256_header = false;
110        signing_options.normalize_uri_path = true;
111        signing_options.payload_override = None;
112
113        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
114            signing_options,
115            ..::std::default::Default::default()
116        });
117
118        ::std::option::Option::Some(cfg.freeze())
119    }
120
121    fn runtime_components(
122        &self,
123        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
124    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
125        #[allow(unused_mut)]
126        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("SendCommand")
127            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
128                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
129            ))
130            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
131                SendCommandEndpointParamsInterceptor,
132            ))
133            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
134                crate::operation::send_command::SendCommandError,
135            >::new())
136            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
137                crate::operation::send_command::SendCommandError,
138            >::new())
139            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
140                crate::operation::send_command::SendCommandError,
141            >::new());
142
143        ::std::borrow::Cow::Owned(rcb)
144    }
145}
146
147#[derive(Debug)]
148struct SendCommandResponseDeserializer;
149impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for SendCommandResponseDeserializer {
150    fn deserialize_nonstreaming_with_config(
151        &self,
152        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
153        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
154    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
155        let (success, status) = (response.status().is_success(), response.status().as_u16());
156        let headers = response.headers();
157        let body = response.body().bytes().expect("body loaded");
158        #[allow(unused_mut)]
159        let mut force_error = false;
160        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
161        let parse_result = if !success && status != 200 || force_error {
162            crate::protocol_serde::shape_send_command::de_send_command_http_error(status, headers, body)
163        } else {
164            crate::protocol_serde::shape_send_command::de_send_command_http_response(status, headers, body)
165        };
166        crate::protocol_serde::type_erase_result(parse_result)
167    }
168}
169#[derive(Debug)]
170struct SendCommandRequestSerializer;
171impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for SendCommandRequestSerializer {
172    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
173    fn serialize_input(
174        &self,
175        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
176        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
177    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
178        let input = input
179            .downcast::<crate::operation::send_command::SendCommandInput>()
180            .expect("correct type");
181        let _header_serialization_settings = _cfg
182            .load::<crate::serialization_settings::HeaderSerializationSettings>()
183            .cloned()
184            .unwrap_or_default();
185        let mut request_builder = {
186            #[allow(clippy::uninlined_format_args)]
187            fn uri_base(
188                _input: &crate::operation::send_command::SendCommandInput,
189                output: &mut ::std::string::String,
190            ) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::BuildError> {
191                use ::std::fmt::Write as _;
192                ::std::write!(output, "/").expect("formatting should succeed");
193                ::std::result::Result::Ok(())
194            }
195            #[allow(clippy::unnecessary_wraps)]
196            fn update_http_builder(
197                input: &crate::operation::send_command::SendCommandInput,
198                builder: ::http_1x::request::Builder,
199            ) -> ::std::result::Result<::http_1x::request::Builder, ::aws_smithy_types::error::operation::BuildError> {
200                let mut uri = ::std::string::String::new();
201                uri_base(input, &mut uri)?;
202                ::std::result::Result::Ok(builder.method("POST").uri(uri))
203            }
204            let mut builder = update_http_builder(&input, ::http_1x::request::Builder::new())?;
205            builder = _header_serialization_settings.set_default_header(builder, ::http_1x::header::CONTENT_TYPE, "application/x-amz-json-1.1");
206            builder = _header_serialization_settings.set_default_header(
207                builder,
208                ::http_1x::header::HeaderName::from_static("x-amz-target"),
209                "AmazonSSM.SendCommand",
210            );
211            builder
212        };
213        let body = ::aws_smithy_types::body::SdkBody::from(crate::protocol_serde::shape_send_command::ser_send_command_input(&input)?);
214        if let Some(content_length) = body.content_length() {
215            let content_length = content_length.to_string();
216            request_builder = _header_serialization_settings.set_default_header(request_builder, ::http_1x::header::CONTENT_LENGTH, &content_length);
217        }
218        ::std::result::Result::Ok(request_builder.body(body).expect("valid request").try_into().unwrap())
219    }
220}
221#[derive(Debug)]
222struct SendCommandEndpointParamsInterceptor;
223
224#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
225impl ::aws_smithy_runtime_api::client::interceptors::Intercept for SendCommandEndpointParamsInterceptor {
226    fn name(&self) -> &'static str {
227        "SendCommandEndpointParamsInterceptor"
228    }
229
230    fn read_before_execution(
231        &self,
232        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
233            '_,
234            ::aws_smithy_runtime_api::client::interceptors::context::Input,
235            ::aws_smithy_runtime_api::client::interceptors::context::Output,
236            ::aws_smithy_runtime_api::client::interceptors::context::Error,
237        >,
238        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
239    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
240        let _input = context
241            .input()
242            .downcast_ref::<SendCommandInput>()
243            .ok_or("failed to downcast to SendCommandInput")?;
244
245        let params = crate::config::endpoint::Params::builder()
246            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
247            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
248            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
249            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
250            .build()
251            .map_err(|err| {
252                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
253            })?;
254        cfg.interceptor_state()
255            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
256        ::std::result::Result::Ok(())
257    }
258}
259
260// The get_* functions below are generated from JMESPath expressions in the
261// operationContextParams trait. They target the operation's input shape.
262
263/// Error type for the `SendCommandError` operation.
264#[non_exhaustive]
265#[derive(::std::fmt::Debug)]
266pub enum SendCommandError {
267    /// <p>You can't specify a managed node ID in more than one association.</p>
268    DuplicateInstanceId(crate::types::error::DuplicateInstanceId),
269    /// <p>An error occurred on the server side.</p>
270    InternalServerError(crate::types::error::InternalServerError),
271    /// <p>The specified SSM document doesn't exist.</p>
272    InvalidDocument(crate::types::error::InvalidDocument),
273    /// <p>The document version isn't valid or doesn't exist.</p>
274    InvalidDocumentVersion(crate::types::error::InvalidDocumentVersion),
275    /// <p>The following problems can cause this exception:</p>
276    /// <ul>
277    /// <li>
278    /// <p>You don't have permission to access the managed node.</p></li>
279    /// <li>
280    /// <p>Amazon Web Services Systems Manager Agent (SSM Agent) isn't running. Verify that SSM Agent is running.</p></li>
281    /// <li>
282    /// <p>SSM Agent isn't registered with the SSM endpoint. Try reinstalling SSM Agent.</p></li>
283    /// <li>
284    /// <p>The managed node isn't in a valid state. Valid states are: <code>Running</code>, <code>Pending</code>, <code>Stopped</code>, and <code>Stopping</code>. Invalid states are: <code>Shutting-down</code> and <code>Terminated</code>.</p></li>
285    /// </ul>
286    InvalidInstanceId(crate::types::error::InvalidInstanceId),
287    /// <p>One or more configuration items isn't valid. Verify that a valid Amazon Resource Name (ARN) was provided for an Amazon Simple Notification Service topic.</p>
288    InvalidNotificationConfig(crate::types::error::InvalidNotificationConfig),
289    /// <p>The S3 bucket doesn't exist.</p>
290    InvalidOutputFolder(crate::types::error::InvalidOutputFolder),
291    /// <p>You must specify values for all required parameters in the Amazon Web Services Systems Manager document (SSM document). You can only supply values to parameters defined in the SSM document.</p>
292    InvalidParameters(crate::types::error::InvalidParameters),
293    /// <p>The role name can't contain invalid characters. Also verify that you specified an IAM role for notifications that includes the required trust policy. For information about configuring the IAM role for Run Command notifications, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/monitoring-sns-notifications.html">Monitoring Systems Manager status changes using Amazon SNS notifications</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
294    InvalidRole(crate::types::error::InvalidRole),
295    /// <p>The size limit of a document is 64 KB.</p>
296    MaxDocumentSizeExceeded(crate::types::error::MaxDocumentSizeExceeded),
297    /// <p>The document doesn't support the platform type of the given managed node IDs. For example, you sent an document for a Windows managed node to a Linux node.</p>
298    UnsupportedPlatformType(crate::types::error::UnsupportedPlatformType),
299    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
300    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
301    variable wildcard pattern and check `.code()`:
302     \
303    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
304     \
305    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-SendCommandError) for what information is available for the error.")]
306    Unhandled(crate::error::sealed_unhandled::Unhandled),
307}
308impl SendCommandError {
309    /// Creates the `SendCommandError::Unhandled` variant from any error type.
310    pub fn unhandled(
311        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
312    ) -> Self {
313        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
314            source: err.into(),
315            meta: ::std::default::Default::default(),
316        })
317    }
318
319    /// Creates the `SendCommandError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
320    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
321        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
322            source: err.clone().into(),
323            meta: err,
324        })
325    }
326    ///
327    /// Returns error metadata, which includes the error code, message,
328    /// request ID, and potentially additional information.
329    ///
330    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
331        match self {
332            Self::DuplicateInstanceId(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
333            Self::InternalServerError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
334            Self::InvalidDocument(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
335            Self::InvalidDocumentVersion(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
336            Self::InvalidInstanceId(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
337            Self::InvalidNotificationConfig(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
338            Self::InvalidOutputFolder(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
339            Self::InvalidParameters(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
340            Self::InvalidRole(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
341            Self::MaxDocumentSizeExceeded(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
342            Self::UnsupportedPlatformType(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
343            Self::Unhandled(e) => &e.meta,
344        }
345    }
346    /// Returns `true` if the error kind is `SendCommandError::DuplicateInstanceId`.
347    pub fn is_duplicate_instance_id(&self) -> bool {
348        matches!(self, Self::DuplicateInstanceId(_))
349    }
350    /// Returns `true` if the error kind is `SendCommandError::InternalServerError`.
351    pub fn is_internal_server_error(&self) -> bool {
352        matches!(self, Self::InternalServerError(_))
353    }
354    /// Returns `true` if the error kind is `SendCommandError::InvalidDocument`.
355    pub fn is_invalid_document(&self) -> bool {
356        matches!(self, Self::InvalidDocument(_))
357    }
358    /// Returns `true` if the error kind is `SendCommandError::InvalidDocumentVersion`.
359    pub fn is_invalid_document_version(&self) -> bool {
360        matches!(self, Self::InvalidDocumentVersion(_))
361    }
362    /// Returns `true` if the error kind is `SendCommandError::InvalidInstanceId`.
363    pub fn is_invalid_instance_id(&self) -> bool {
364        matches!(self, Self::InvalidInstanceId(_))
365    }
366    /// Returns `true` if the error kind is `SendCommandError::InvalidNotificationConfig`.
367    pub fn is_invalid_notification_config(&self) -> bool {
368        matches!(self, Self::InvalidNotificationConfig(_))
369    }
370    /// Returns `true` if the error kind is `SendCommandError::InvalidOutputFolder`.
371    pub fn is_invalid_output_folder(&self) -> bool {
372        matches!(self, Self::InvalidOutputFolder(_))
373    }
374    /// Returns `true` if the error kind is `SendCommandError::InvalidParameters`.
375    pub fn is_invalid_parameters(&self) -> bool {
376        matches!(self, Self::InvalidParameters(_))
377    }
378    /// Returns `true` if the error kind is `SendCommandError::InvalidRole`.
379    pub fn is_invalid_role(&self) -> bool {
380        matches!(self, Self::InvalidRole(_))
381    }
382    /// Returns `true` if the error kind is `SendCommandError::MaxDocumentSizeExceeded`.
383    pub fn is_max_document_size_exceeded(&self) -> bool {
384        matches!(self, Self::MaxDocumentSizeExceeded(_))
385    }
386    /// Returns `true` if the error kind is `SendCommandError::UnsupportedPlatformType`.
387    pub fn is_unsupported_platform_type(&self) -> bool {
388        matches!(self, Self::UnsupportedPlatformType(_))
389    }
390}
391impl ::std::error::Error for SendCommandError {
392    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
393        match self {
394            Self::DuplicateInstanceId(_inner) => ::std::option::Option::Some(_inner),
395            Self::InternalServerError(_inner) => ::std::option::Option::Some(_inner),
396            Self::InvalidDocument(_inner) => ::std::option::Option::Some(_inner),
397            Self::InvalidDocumentVersion(_inner) => ::std::option::Option::Some(_inner),
398            Self::InvalidInstanceId(_inner) => ::std::option::Option::Some(_inner),
399            Self::InvalidNotificationConfig(_inner) => ::std::option::Option::Some(_inner),
400            Self::InvalidOutputFolder(_inner) => ::std::option::Option::Some(_inner),
401            Self::InvalidParameters(_inner) => ::std::option::Option::Some(_inner),
402            Self::InvalidRole(_inner) => ::std::option::Option::Some(_inner),
403            Self::MaxDocumentSizeExceeded(_inner) => ::std::option::Option::Some(_inner),
404            Self::UnsupportedPlatformType(_inner) => ::std::option::Option::Some(_inner),
405            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
406        }
407    }
408}
409impl ::std::fmt::Display for SendCommandError {
410    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
411        match self {
412            Self::DuplicateInstanceId(_inner) => _inner.fmt(f),
413            Self::InternalServerError(_inner) => _inner.fmt(f),
414            Self::InvalidDocument(_inner) => _inner.fmt(f),
415            Self::InvalidDocumentVersion(_inner) => _inner.fmt(f),
416            Self::InvalidInstanceId(_inner) => _inner.fmt(f),
417            Self::InvalidNotificationConfig(_inner) => _inner.fmt(f),
418            Self::InvalidOutputFolder(_inner) => _inner.fmt(f),
419            Self::InvalidParameters(_inner) => _inner.fmt(f),
420            Self::InvalidRole(_inner) => _inner.fmt(f),
421            Self::MaxDocumentSizeExceeded(_inner) => _inner.fmt(f),
422            Self::UnsupportedPlatformType(_inner) => _inner.fmt(f),
423            Self::Unhandled(_inner) => {
424                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
425                    write!(f, "unhandled error ({code})")
426                } else {
427                    f.write_str("unhandled error")
428                }
429            }
430        }
431    }
432}
433impl ::aws_smithy_types::retry::ProvideErrorKind for SendCommandError {
434    fn code(&self) -> ::std::option::Option<&str> {
435        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
436    }
437    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
438        ::std::option::Option::None
439    }
440}
441impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for SendCommandError {
442    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
443        match self {
444            Self::DuplicateInstanceId(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
445            Self::InternalServerError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
446            Self::InvalidDocument(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
447            Self::InvalidDocumentVersion(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
448            Self::InvalidInstanceId(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
449            Self::InvalidNotificationConfig(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
450            Self::InvalidOutputFolder(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
451            Self::InvalidParameters(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
452            Self::InvalidRole(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
453            Self::MaxDocumentSizeExceeded(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
454            Self::UnsupportedPlatformType(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
455            Self::Unhandled(_inner) => &_inner.meta,
456        }
457    }
458}
459impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for SendCommandError {
460    fn create_unhandled_error(
461        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
462        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
463    ) -> Self {
464        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
465            source,
466            meta: meta.unwrap_or_default(),
467        })
468    }
469}
470impl ::aws_types::request_id::RequestId for crate::operation::send_command::SendCommandError {
471    fn request_id(&self) -> Option<&str> {
472        self.meta().request_id()
473    }
474}
475
476pub use crate::operation::send_command::_send_command_input::SendCommandInput;
477
478pub use crate::operation::send_command::_send_command_output::SendCommandOutput;
479
480mod _send_command_input;
481
482mod _send_command_output;
483
484/// Builders
485pub mod builders;