AWS SDK

AWS SDK

rev. bbca34fa2eddb4be623fbbc6b6df1a2401de0029

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/register_task_with_maintenance_window/_register_task_with_maintenance_window_output.rs

@@ -0,1 +0,186 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
#[allow(missing_docs)] // documentation missing in model
           3  +
#[non_exhaustive]
           4  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
           5  +
pub struct RegisterTaskWithMaintenanceWindowOutput {
           6  +
    /// <p>The ID of the task in the maintenance window.</p>
           7  +
    pub window_task_id: ::std::option::Option<::std::string::String>,
           8  +
    _request_id: Option<String>,
           9  +
}
          10  +
impl RegisterTaskWithMaintenanceWindowOutput {
          11  +
    /// <p>The ID of the task in the maintenance window.</p>
          12  +
    pub fn window_task_id(&self) -> ::std::option::Option<&str> {
          13  +
        self.window_task_id.as_deref()
          14  +
    }
          15  +
}
          16  +
static REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_MEMBER_WINDOW_TASK_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          17  +
    ::aws_smithy_schema::ShapeId::from_parts(
          18  +
        "com.amazonaws.ssm.synthetic#RegisterTaskWithMaintenanceWindowOutput$WindowTaskId",
          19  +
        "com.amazonaws.ssm.synthetic",
          20  +
        "RegisterTaskWithMaintenanceWindowOutput",
          21  +
    ),
          22  +
    ::aws_smithy_schema::ShapeType::String,
          23  +
    "WindowTaskId",
          24  +
    0,
          25  +
);
          26  +
static REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          27  +
    ::aws_smithy_schema::ShapeId::from_parts("synthetic#request_id", "synthetic", "request_id"),
          28  +
    ::aws_smithy_schema::ShapeType::String,
          29  +
    "request_id",
          30  +
    1,
          31  +
)
          32  +
.with_http_header("x-amzn-requestid");
          33  +
static REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          34  +
    ::aws_smithy_schema::ShapeId::from_parts(
          35  +
        "com.amazonaws.ssm.synthetic#RegisterTaskWithMaintenanceWindowOutput",
          36  +
        "com.amazonaws.ssm.synthetic",
          37  +
        "RegisterTaskWithMaintenanceWindowOutput",
          38  +
    ),
          39  +
    ::aws_smithy_schema::ShapeType::Structure,
          40  +
    &[
          41  +
        &REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_MEMBER_WINDOW_TASK_ID,
          42  +
        &REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_MEMBER__REQUEST_ID,
          43  +
    ],
          44  +
)
          45  +
.with_original_name("RegisterTaskWithMaintenanceWindowResult");
          46  +
impl RegisterTaskWithMaintenanceWindowOutput {
          47  +
    /// The schema for this shape.
          48  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_SCHEMA;
          49  +
}
          50  +
impl ::aws_smithy_schema::serde::SerializableStruct for RegisterTaskWithMaintenanceWindowOutput {
          51  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          52  +
    fn serialize_members(
          53  +
        &self,
          54  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          55  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          56  +
        if let Some(ref val) = self.window_task_id {
          57  +
            ser.write_string(&REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_MEMBER_WINDOW_TASK_ID, val)?;
          58  +
        }
          59  +
        Ok(())
          60  +
    }
          61  +
}
          62  +
impl RegisterTaskWithMaintenanceWindowOutput {
          63  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          64  +
    pub fn deserialize(
          65  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          66  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          67  +
        #[allow(unused_variables, unused_mut)]
          68  +
        let mut builder = Self::builder();
          69  +
        #[allow(
          70  +
            unused_variables,
          71  +
            unreachable_code,
          72  +
            clippy::single_match,
          73  +
            clippy::match_single_binding,
          74  +
            clippy::diverging_sub_expression
          75  +
        )]
          76  +
        deserializer.read_struct(&REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_SCHEMA, &mut |member, deser| {
          77  +
            match member.member_index() {
          78  +
                Some(0) => {
          79  +
                    if deser.is_null() {
          80  +
                        deser.read_null()?;
          81  +
                    } else {
          82  +
                        builder.window_task_id = Some(deser.read_string(member)?);
          83  +
                    }
          84  +
                }
          85  +
                Some(1) => {
          86  +
                    builder._request_id = Some(deser.read_string(member)?);
          87  +
                }
          88  +
                _ => {}
          89  +
            }
          90  +
            Ok(())
          91  +
        })?;
          92  +
        Ok(builder.build())
          93  +
    }
          94  +
}
          95  +
impl RegisterTaskWithMaintenanceWindowOutput {
          96  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          97  +
    /// Header-bound members are read directly from headers, avoiding runtime
          98  +
    /// member iteration overhead. Body members are read via the deserializer.
          99  +
    pub fn deserialize_with_response(
         100  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         101  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         102  +
        _status: u16,
         103  +
        _body: &[u8],
         104  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         105  +
        #[allow(unused_variables, unused_mut)]
         106  +
        let mut builder = Self::builder();
         107  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         108  +
            builder._request_id = Some(val.to_string());
         109  +
        }
         110  +
         111  +
        #[allow(
         112  +
            unused_variables,
         113  +
            unreachable_code,
         114  +
            clippy::single_match,
         115  +
            clippy::match_single_binding,
         116  +
            clippy::diverging_sub_expression
         117  +
        )]
         118  +
        deserializer.read_struct(&REGISTERTASKWITHMAINTENANCEWINDOWOUTPUT_SCHEMA, &mut |member, deser| {
         119  +
            match member.member_index() {
         120  +
                Some(0) => {
         121  +
                    builder.window_task_id = Some(deser.read_string(member)?);
         122  +
                }
         123  +
                _ => {}
         124  +
            }
         125  +
            Ok(())
         126  +
        })?;
         127  +
        Ok(builder.build())
         128  +
    }
         129  +
}
         130  +
impl ::aws_types::request_id::RequestId for RegisterTaskWithMaintenanceWindowOutput {
         131  +
    fn request_id(&self) -> Option<&str> {
         132  +
        self._request_id.as_deref()
         133  +
    }
         134  +
}
         135  +
impl RegisterTaskWithMaintenanceWindowOutput {
         136  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         137  +
        self._request_id = request_id;
         138  +
        self
         139  +
    }
         140  +
}
         141  +
impl RegisterTaskWithMaintenanceWindowOutput {
         142  +
    /// Creates a new builder-style object to manufacture [`RegisterTaskWithMaintenanceWindowOutput`](crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput).
         143  +
    pub fn builder() -> crate::operation::register_task_with_maintenance_window::builders::RegisterTaskWithMaintenanceWindowOutputBuilder {
         144  +
        crate::operation::register_task_with_maintenance_window::builders::RegisterTaskWithMaintenanceWindowOutputBuilder::default()
         145  +
    }
         146  +
}
         147  +
         148  +
/// A builder for [`RegisterTaskWithMaintenanceWindowOutput`](crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput).
         149  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         150  +
#[non_exhaustive]
         151  +
pub struct RegisterTaskWithMaintenanceWindowOutputBuilder {
         152  +
    pub(crate) window_task_id: ::std::option::Option<::std::string::String>,
         153  +
    _request_id: Option<String>,
         154  +
}
         155  +
impl RegisterTaskWithMaintenanceWindowOutputBuilder {
         156  +
    /// <p>The ID of the task in the maintenance window.</p>
         157  +
    pub fn window_task_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         158  +
        self.window_task_id = ::std::option::Option::Some(input.into());
         159  +
        self
         160  +
    }
         161  +
    /// <p>The ID of the task in the maintenance window.</p>
         162  +
    pub fn set_window_task_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         163  +
        self.window_task_id = input;
         164  +
        self
         165  +
    }
         166  +
    /// <p>The ID of the task in the maintenance window.</p>
         167  +
    pub fn get_window_task_id(&self) -> &::std::option::Option<::std::string::String> {
         168  +
        &self.window_task_id
         169  +
    }
         170  +
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         171  +
        self._request_id = Some(request_id.into());
         172  +
        self
         173  +
    }
         174  +
         175  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         176  +
        self._request_id = request_id;
         177  +
        self
         178  +
    }
         179  +
    /// Consumes the builder and constructs a [`RegisterTaskWithMaintenanceWindowOutput`](crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput).
         180  +
    pub fn build(self) -> crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput {
         181  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput {
         182  +
            window_task_id: self.window_task_id,
         183  +
            _request_id: self._request_id,
         184  +
        }
         185  +
    }
         186  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/register_task_with_maintenance_window/builders.rs

@@ -0,1 +0,462 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub use crate::operation::register_task_with_maintenance_window::_register_task_with_maintenance_window_input::RegisterTaskWithMaintenanceWindowInputBuilder;
           3  +
           4  +
pub use crate::operation::register_task_with_maintenance_window::_register_task_with_maintenance_window_output::RegisterTaskWithMaintenanceWindowOutputBuilder;
           5  +
           6  +
impl crate::operation::register_task_with_maintenance_window::builders::RegisterTaskWithMaintenanceWindowInputBuilder {
           7  +
    /// Sends a request with this input using the given client.
           8  +
    pub async fn send_with(
           9  +
        self,
          10  +
        client: &crate::Client,
          11  +
    ) -> ::std::result::Result<
          12  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput,
          13  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          14  +
            crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError,
          15  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          16  +
        >,
          17  +
    > {
          18  +
        let mut fluent_builder = client.register_task_with_maintenance_window();
          19  +
        fluent_builder.inner = self;
          20  +
        fluent_builder.send().await
          21  +
    }
          22  +
}
          23  +
/// Fluent builder constructing a request to `RegisterTaskWithMaintenanceWindow`.
          24  +
///
          25  +
/// <p>Adds a new task to a maintenance window.</p>
          26  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
          27  +
pub struct RegisterTaskWithMaintenanceWindowFluentBuilder {
          28  +
    handle: ::std::sync::Arc<crate::client::Handle>,
          29  +
    inner: crate::operation::register_task_with_maintenance_window::builders::RegisterTaskWithMaintenanceWindowInputBuilder,
          30  +
    config_override: ::std::option::Option<crate::config::Builder>,
          31  +
}
          32  +
impl
          33  +
    crate::client::customize::internal::CustomizableSend<
          34  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput,
          35  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError,
          36  +
    > for RegisterTaskWithMaintenanceWindowFluentBuilder
          37  +
{
          38  +
    fn send(
          39  +
        self,
          40  +
        config_override: crate::config::Builder,
          41  +
    ) -> crate::client::customize::internal::BoxFuture<
          42  +
        crate::client::customize::internal::SendResult<
          43  +
            crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput,
          44  +
            crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError,
          45  +
        >,
          46  +
    > {
          47  +
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
          48  +
    }
          49  +
}
          50  +
impl RegisterTaskWithMaintenanceWindowFluentBuilder {
          51  +
    /// Creates a new `RegisterTaskWithMaintenanceWindowFluentBuilder`.
          52  +
    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
          53  +
        Self {
          54  +
            handle,
          55  +
            inner: ::std::default::Default::default(),
          56  +
            config_override: ::std::option::Option::None,
          57  +
        }
          58  +
    }
          59  +
    /// Access the RegisterTaskWithMaintenanceWindow as a reference.
          60  +
    pub fn as_input(&self) -> &crate::operation::register_task_with_maintenance_window::builders::RegisterTaskWithMaintenanceWindowInputBuilder {
          61  +
        &self.inner
          62  +
    }
          63  +
    /// Sends the request and returns the response.
          64  +
    ///
          65  +
    /// If an error occurs, an `SdkError` will be returned with additional details that
          66  +
    /// can be matched against.
          67  +
    ///
          68  +
    /// By default, any retryable failures will be retried twice. Retry behavior
          69  +
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
          70  +
    /// set when configuring the client.
          71  +
    pub async fn send(
          72  +
        self,
          73  +
    ) -> ::std::result::Result<
          74  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput,
          75  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          76  +
            crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError,
          77  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          78  +
        >,
          79  +
    > {
          80  +
        let input = self
          81  +
            .inner
          82  +
            .build()
          83  +
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
          84  +
        let runtime_plugins = crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindow::operation_runtime_plugins(
          85  +
            self.handle.runtime_plugins.clone(),
          86  +
            &self.handle.conf,
          87  +
            self.config_override,
          88  +
        );
          89  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindow::orchestrate(&runtime_plugins, input).await
          90  +
    }
          91  +
          92  +
    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
          93  +
    pub fn customize(
          94  +
        self,
          95  +
    ) -> crate::client::customize::CustomizableOperation<
          96  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowOutput,
          97  +
        crate::operation::register_task_with_maintenance_window::RegisterTaskWithMaintenanceWindowError,
          98  +
        Self,
          99  +
    > {
         100  +
        crate::client::customize::CustomizableOperation::new(self)
         101  +
    }
         102  +
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         103  +
        self.set_config_override(::std::option::Option::Some(config_override.into()));
         104  +
        self
         105  +
    }
         106  +
         107  +
    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         108  +
        self.config_override = config_override;
         109  +
        self
         110  +
    }
         111  +
    /// <p>The ID of the maintenance window the task should be added to.</p>
         112  +
    pub fn window_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         113  +
        self.inner = self.inner.window_id(input.into());
         114  +
        self
         115  +
    }
         116  +
    /// <p>The ID of the maintenance window the task should be added to.</p>
         117  +
    pub fn set_window_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         118  +
        self.inner = self.inner.set_window_id(input);
         119  +
        self
         120  +
    }
         121  +
    /// <p>The ID of the maintenance window the task should be added to.</p>
         122  +
    pub fn get_window_id(&self) -> &::std::option::Option<::std::string::String> {
         123  +
        self.inner.get_window_id()
         124  +
    }
         125  +
    ///
         126  +
    /// Appends an item to `Targets`.
         127  +
    ///
         128  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
         129  +
    ///
         130  +
    /// <p>The targets (either managed nodes or maintenance window targets).</p><note>
         131  +
    /// <p>One or more targets must be specified for maintenance window Run Command-type tasks. Depending on the task, targets are optional for other maintenance window task types (Automation, Lambda, and Step Functions). For more information about running tasks that don't specify targets, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">Registering maintenance window tasks without targets</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         132  +
    /// </note>
         133  +
    /// <p>Specify managed nodes using the following format:</p>
         134  +
    /// <p><code>Key=InstanceIds,Values=<instance-id-1>
         135  +
    /// ,
         136  +
    /// <instance-id-2></instance-id-2>
         137  +
    /// </instance-id-1></code></p>
         138  +
    /// <p>Specify maintenance window targets using the following format:</p>
         139  +
    /// <p><code>Key=WindowTargetIds,Values=<window-target-id-1>
         140  +
    /// ,
         141  +
    /// <window-target-id-2></window-target-id-2>
         142  +
    /// </window-target-id-1></code></p>
         143  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
         144  +
        self.inner = self.inner.targets(input);
         145  +
        self
         146  +
    }
         147  +
    /// <p>The targets (either managed nodes or maintenance window targets).</p><note>
         148  +
    /// <p>One or more targets must be specified for maintenance window Run Command-type tasks. Depending on the task, targets are optional for other maintenance window task types (Automation, Lambda, and Step Functions). For more information about running tasks that don't specify targets, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">Registering maintenance window tasks without targets</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         149  +
    /// </note>
         150  +
    /// <p>Specify managed nodes using the following format:</p>
         151  +
    /// <p><code>Key=InstanceIds,Values=<instance-id-1>
         152  +
    /// ,
         153  +
    /// <instance-id-2></instance-id-2>
         154  +
    /// </instance-id-1></code></p>
         155  +
    /// <p>Specify maintenance window targets using the following format:</p>
         156  +
    /// <p><code>Key=WindowTargetIds,Values=<window-target-id-1>
         157  +
    /// ,
         158  +
    /// <window-target-id-2></window-target-id-2>
         159  +
    /// </window-target-id-1></code></p>
         160  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
         161  +
        self.inner = self.inner.set_targets(input);
         162  +
        self
         163  +
    }
         164  +
    /// <p>The targets (either managed nodes or maintenance window targets).</p><note>
         165  +
    /// <p>One or more targets must be specified for maintenance window Run Command-type tasks. Depending on the task, targets are optional for other maintenance window task types (Automation, Lambda, and Step Functions). For more information about running tasks that don't specify targets, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">Registering maintenance window tasks without targets</a> in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         166  +
    /// </note>
         167  +
    /// <p>Specify managed nodes using the following format:</p>
         168  +
    /// <p><code>Key=InstanceIds,Values=<instance-id-1>
         169  +
    /// ,
         170  +
    /// <instance-id-2></instance-id-2>
         171  +
    /// </instance-id-1></code></p>
         172  +
    /// <p>Specify maintenance window targets using the following format:</p>
         173  +
    /// <p><code>Key=WindowTargetIds,Values=<window-target-id-1>
         174  +
    /// ,
         175  +
    /// <window-target-id-2></window-target-id-2>
         176  +
    /// </window-target-id-1></code></p>
         177  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
         178  +
        self.inner.get_targets()
         179  +
    }
         180  +
    /// <p>The ARN of the task to run.</p>
         181  +
    pub fn task_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         182  +
        self.inner = self.inner.task_arn(input.into());
         183  +
        self
         184  +
    }
         185  +
    /// <p>The ARN of the task to run.</p>
         186  +
    pub fn set_task_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         187  +
        self.inner = self.inner.set_task_arn(input);
         188  +
        self
         189  +
    }
         190  +
    /// <p>The ARN of the task to run.</p>
         191  +
    pub fn get_task_arn(&self) -> &::std::option::Option<::std::string::String> {
         192  +
        self.inner.get_task_arn()
         193  +
    }
         194  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         195  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         196  +
    pub fn service_role_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         197  +
        self.inner = self.inner.service_role_arn(input.into());
         198  +
        self
         199  +
    }
         200  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         201  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         202  +
    pub fn set_service_role_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         203  +
        self.inner = self.inner.set_service_role_arn(input);
         204  +
        self
         205  +
    }
         206  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         207  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         208  +
    pub fn get_service_role_arn(&self) -> &::std::option::Option<::std::string::String> {
         209  +
        self.inner.get_service_role_arn()
         210  +
    }
         211  +
    /// <p>The type of task being registered.</p>
         212  +
    pub fn task_type(mut self, input: crate::types::MaintenanceWindowTaskType) -> Self {
         213  +
        self.inner = self.inner.task_type(input);
         214  +
        self
         215  +
    }
         216  +
    /// <p>The type of task being registered.</p>
         217  +
    pub fn set_task_type(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskType>) -> Self {
         218  +
        self.inner = self.inner.set_task_type(input);
         219  +
        self
         220  +
    }
         221  +
    /// <p>The type of task being registered.</p>
         222  +
    pub fn get_task_type(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskType> {
         223  +
        self.inner.get_task_type()
         224  +
    }
         225  +
    ///
         226  +
    /// Adds a key-value pair to `TaskParameters`.
         227  +
    ///
         228  +
    /// To override the contents of this collection use [`set_task_parameters`](Self::set_task_parameters).
         229  +
    ///
         230  +
    /// <p>The parameters that should be passed to the task when it is run.</p><note>
         231  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         232  +
    /// </note>
         233  +
    pub fn task_parameters(
         234  +
        mut self,
         235  +
        k: impl ::std::convert::Into<::std::string::String>,
         236  +
        v: crate::types::MaintenanceWindowTaskParameterValueExpression,
         237  +
    ) -> Self {
         238  +
        self.inner = self.inner.task_parameters(k.into(), v);
         239  +
        self
         240  +
    }
         241  +
    /// <p>The parameters that should be passed to the task when it is run.</p><note>
         242  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         243  +
    /// </note>
         244  +
    pub fn set_task_parameters(
         245  +
        mut self,
         246  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>>,
         247  +
    ) -> Self {
         248  +
        self.inner = self.inner.set_task_parameters(input);
         249  +
        self
         250  +
    }
         251  +
    /// <p>The parameters that should be passed to the task when it is run.</p><note>
         252  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         253  +
    /// </note>
         254  +
    pub fn get_task_parameters(
         255  +
        &self,
         256  +
    ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>> {
         257  +
        self.inner.get_task_parameters()
         258  +
    }
         259  +
    /// <p>The parameters that the task should use during execution. Populate only the fields that match the task type. All other fields should be empty.</p>
         260  +
    pub fn task_invocation_parameters(mut self, input: crate::types::MaintenanceWindowTaskInvocationParameters) -> Self {
         261  +
        self.inner = self.inner.task_invocation_parameters(input);
         262  +
        self
         263  +
    }
         264  +
    /// <p>The parameters that the task should use during execution. Populate only the fields that match the task type. All other fields should be empty.</p>
         265  +
    pub fn set_task_invocation_parameters(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters>) -> Self {
         266  +
        self.inner = self.inner.set_task_invocation_parameters(input);
         267  +
        self
         268  +
    }
         269  +
    /// <p>The parameters that the task should use during execution. Populate only the fields that match the task type. All other fields should be empty.</p>
         270  +
    pub fn get_task_invocation_parameters(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters> {
         271  +
        self.inner.get_task_invocation_parameters()
         272  +
    }
         273  +
    /// <p>The priority of the task in the maintenance window, the lower the number the higher the priority. Tasks in a maintenance window are scheduled in priority order with tasks that have the same priority scheduled in parallel.</p>
         274  +
    pub fn priority(mut self, input: i32) -> Self {
         275  +
        self.inner = self.inner.priority(input);
         276  +
        self
         277  +
    }
         278  +
    /// <p>The priority of the task in the maintenance window, the lower the number the higher the priority. Tasks in a maintenance window are scheduled in priority order with tasks that have the same priority scheduled in parallel.</p>
         279  +
    pub fn set_priority(mut self, input: ::std::option::Option<i32>) -> Self {
         280  +
        self.inner = self.inner.set_priority(input);
         281  +
        self
         282  +
    }
         283  +
    /// <p>The priority of the task in the maintenance window, the lower the number the higher the priority. Tasks in a maintenance window are scheduled in priority order with tasks that have the same priority scheduled in parallel.</p>
         284  +
    pub fn get_priority(&self) -> &::std::option::Option<i32> {
         285  +
        self.inner.get_priority()
         286  +
    }
         287  +
    /// <p>The maximum number of targets this task can be run for, in parallel.</p><note>
         288  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         289  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         290  +
    /// </note>
         291  +
    pub fn max_concurrency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         292  +
        self.inner = self.inner.max_concurrency(input.into());
         293  +
        self
         294  +
    }
         295  +
    /// <p>The maximum number of targets this task can be run for, in parallel.</p><note>
         296  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         297  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         298  +
    /// </note>
         299  +
    pub fn set_max_concurrency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         300  +
        self.inner = self.inner.set_max_concurrency(input);
         301  +
        self
         302  +
    }
         303  +
    /// <p>The maximum number of targets this task can be run for, in parallel.</p><note>
         304  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         305  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         306  +
    /// </note>
         307  +
    pub fn get_max_concurrency(&self) -> &::std::option::Option<::std::string::String> {
         308  +
        self.inner.get_max_concurrency()
         309  +
    }
         310  +
    /// <p>The maximum number of errors allowed before this task stops being scheduled.</p><note>
         311  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         312  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         313  +
    /// </note>
         314  +
    pub fn max_errors(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         315  +
        self.inner = self.inner.max_errors(input.into());
         316  +
        self
         317  +
    }
         318  +
    /// <p>The maximum number of errors allowed before this task stops being scheduled.</p><note>
         319  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         320  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         321  +
    /// </note>
         322  +
    pub fn set_max_errors(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         323  +
        self.inner = self.inner.set_max_errors(input);
         324  +
        self
         325  +
    }
         326  +
    /// <p>The maximum number of errors allowed before this task stops being scheduled.</p><note>
         327  +
    /// <p>Although this element is listed as "Required: No", a value can be omitted only when you are registering or updating a <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/maintenance-windows-targetless-tasks.html">targetless task</a> You must provide a value in all other cases.</p>
         328  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>. This value doesn't affect the running of your task.</p>
         329  +
    /// </note>
         330  +
    pub fn get_max_errors(&self) -> &::std::option::Option<::std::string::String> {
         331  +
        self.inner.get_max_errors()
         332  +
    }
         333  +
    /// <p>A structure containing information about an Amazon Simple Storage Service (Amazon S3) bucket to write managed node-level logs to.</p><note>
         334  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         335  +
    /// </note>
         336  +
    pub fn logging_info(mut self, input: crate::types::LoggingInfo) -> Self {
         337  +
        self.inner = self.inner.logging_info(input);
         338  +
        self
         339  +
    }
         340  +
    /// <p>A structure containing information about an Amazon Simple Storage Service (Amazon S3) bucket to write managed node-level logs to.</p><note>
         341  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         342  +
    /// </note>
         343  +
    pub fn set_logging_info(mut self, input: ::std::option::Option<crate::types::LoggingInfo>) -> Self {
         344  +
        self.inner = self.inner.set_logging_info(input);
         345  +
        self
         346  +
    }
         347  +
    /// <p>A structure containing information about an Amazon Simple Storage Service (Amazon S3) bucket to write managed node-level logs to.</p><note>
         348  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         349  +
    /// </note>
         350  +
    pub fn get_logging_info(&self) -> &::std::option::Option<crate::types::LoggingInfo> {
         351  +
        self.inner.get_logging_info()
         352  +
    }
         353  +
    /// <p>An optional name for the task.</p>
         354  +
    pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         355  +
        self.inner = self.inner.name(input.into());
         356  +
        self
         357  +
    }
         358  +
    /// <p>An optional name for the task.</p>
         359  +
    pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         360  +
        self.inner = self.inner.set_name(input);
         361  +
        self
         362  +
    }
         363  +
    /// <p>An optional name for the task.</p>
         364  +
    pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         365  +
        self.inner.get_name()
         366  +
    }
         367  +
    /// <p>An optional description for the task.</p>
         368  +
    pub fn description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         369  +
        self.inner = self.inner.description(input.into());
         370  +
        self
         371  +
    }
         372  +
    /// <p>An optional description for the task.</p>
         373  +
    pub fn set_description(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         374  +
        self.inner = self.inner.set_description(input);
         375  +
        self
         376  +
    }
         377  +
    /// <p>An optional description for the task.</p>
         378  +
    pub fn get_description(&self) -> &::std::option::Option<::std::string::String> {
         379  +
        self.inner.get_description()
         380  +
    }
         381  +
    /// <p>User-provided idempotency token.</p>
         382  +
    pub fn client_token(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         383  +
        self.inner = self.inner.client_token(input.into());
         384  +
        self
         385  +
    }
         386  +
    /// <p>User-provided idempotency token.</p>
         387  +
    pub fn set_client_token(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         388  +
        self.inner = self.inner.set_client_token(input);
         389  +
        self
         390  +
    }
         391  +
    /// <p>User-provided idempotency token.</p>
         392  +
    pub fn get_client_token(&self) -> &::std::option::Option<::std::string::String> {
         393  +
        self.inner.get_client_token()
         394  +
    }
         395  +
    /// <p>Indicates whether tasks should continue to run after the cutoff time specified in the maintenance windows is reached.</p>
         396  +
    /// <ul>
         397  +
    /// <li>
         398  +
    /// <p><code>CONTINUE_TASK</code>: When the cutoff time is reached, any tasks that are running continue. The default value.</p></li>
         399  +
    /// <li>
         400  +
    /// <p><code>CANCEL_TASK</code>:</p>
         401  +
    /// <ul>
         402  +
    /// <li>
         403  +
    /// <p>For Automation, Lambda, Step Functions tasks: When the cutoff time is reached, any task invocations that are already running continue, but no new task invocations are started.</p></li>
         404  +
    /// <li>
         405  +
    /// <p>For Run Command tasks: When the cutoff time is reached, the system sends a <code>CancelCommand</code> operation that attempts to cancel the command associated with the task. However, there is no guarantee that the command will be terminated and the underlying process stopped.</p></li>
         406  +
    /// </ul>
         407  +
    /// <p>The status for tasks that are not completed is <code>TIMED_OUT</code>.</p></li>
         408  +
    /// </ul>
         409  +
    pub fn cutoff_behavior(mut self, input: crate::types::MaintenanceWindowTaskCutoffBehavior) -> Self {
         410  +
        self.inner = self.inner.cutoff_behavior(input);
         411  +
        self
         412  +
    }
         413  +
    /// <p>Indicates whether tasks should continue to run after the cutoff time specified in the maintenance windows is reached.</p>
         414  +
    /// <ul>
         415  +
    /// <li>
         416  +
    /// <p><code>CONTINUE_TASK</code>: When the cutoff time is reached, any tasks that are running continue. The default value.</p></li>
         417  +
    /// <li>
         418  +
    /// <p><code>CANCEL_TASK</code>:</p>
         419  +
    /// <ul>
         420  +
    /// <li>
         421  +
    /// <p>For Automation, Lambda, Step Functions tasks: When the cutoff time is reached, any task invocations that are already running continue, but no new task invocations are started.</p></li>
         422  +
    /// <li>
         423  +
    /// <p>For Run Command tasks: When the cutoff time is reached, the system sends a <code>CancelCommand</code> operation that attempts to cancel the command associated with the task. However, there is no guarantee that the command will be terminated and the underlying process stopped.</p></li>
         424  +
    /// </ul>
         425  +
    /// <p>The status for tasks that are not completed is <code>TIMED_OUT</code>.</p></li>
         426  +
    /// </ul>
         427  +
    pub fn set_cutoff_behavior(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior>) -> Self {
         428  +
        self.inner = self.inner.set_cutoff_behavior(input);
         429  +
        self
         430  +
    }
         431  +
    /// <p>Indicates whether tasks should continue to run after the cutoff time specified in the maintenance windows is reached.</p>
         432  +
    /// <ul>
         433  +
    /// <li>
         434  +
    /// <p><code>CONTINUE_TASK</code>: When the cutoff time is reached, any tasks that are running continue. The default value.</p></li>
         435  +
    /// <li>
         436  +
    /// <p><code>CANCEL_TASK</code>:</p>
         437  +
    /// <ul>
         438  +
    /// <li>
         439  +
    /// <p>For Automation, Lambda, Step Functions tasks: When the cutoff time is reached, any task invocations that are already running continue, but no new task invocations are started.</p></li>
         440  +
    /// <li>
         441  +
    /// <p>For Run Command tasks: When the cutoff time is reached, the system sends a <code>CancelCommand</code> operation that attempts to cancel the command associated with the task. However, there is no guarantee that the command will be terminated and the underlying process stopped.</p></li>
         442  +
    /// </ul>
         443  +
    /// <p>The status for tasks that are not completed is <code>TIMED_OUT</code>.</p></li>
         444  +
    /// </ul>
         445  +
    pub fn get_cutoff_behavior(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior> {
         446  +
        self.inner.get_cutoff_behavior()
         447  +
    }
         448  +
    /// <p>The CloudWatch alarm you want to apply to your maintenance window task.</p>
         449  +
    pub fn alarm_configuration(mut self, input: crate::types::AlarmConfiguration) -> Self {
         450  +
        self.inner = self.inner.alarm_configuration(input);
         451  +
        self
         452  +
    }
         453  +
    /// <p>The CloudWatch alarm you want to apply to your maintenance window task.</p>
         454  +
    pub fn set_alarm_configuration(mut self, input: ::std::option::Option<crate::types::AlarmConfiguration>) -> Self {
         455  +
        self.inner = self.inner.set_alarm_configuration(input);
         456  +
        self
         457  +
    }
         458  +
    /// <p>The CloudWatch alarm you want to apply to your maintenance window task.</p>
         459  +
    pub fn get_alarm_configuration(&self) -> &::std::option::Option<crate::types::AlarmConfiguration> {
         460  +
        self.inner.get_alarm_configuration()
         461  +
    }
         462  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/remove_tags_from_resource.rs

@@ -0,1 +0,644 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/// Orchestration and serialization glue logic for `RemoveTagsFromResource`.
           3  +
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
           4  +
#[non_exhaustive]
           5  +
pub struct RemoveTagsFromResource;
           6  +
impl RemoveTagsFromResource {
           7  +
    /// Creates a new `RemoveTagsFromResource`
           8  +
    pub fn new() -> Self {
           9  +
        Self
          10  +
    }
          11  +
    /// The schema for this operation's input shape.
          12  +
    pub const INPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
          13  +
        crate::operation::remove_tags_from_resource::RemoveTagsFromResourceInput::SCHEMA;
          14  +
    /// The schema for this operation's output shape.
          15  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> =
          16  +
        crate::operation::remove_tags_from_resource::RemoveTagsFromResourceOutput::SCHEMA;
          17  +
    pub(crate) async fn orchestrate(
          18  +
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          19  +
        input: crate::operation::remove_tags_from_resource::RemoveTagsFromResourceInput,
          20  +
    ) -> ::std::result::Result<
          21  +
        crate::operation::remove_tags_from_resource::RemoveTagsFromResourceOutput,
          22  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          23  +
            crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
          24  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          25  +
        >,
          26  +
    > {
          27  +
        let map_err = |err: ::aws_smithy_runtime_api::client::result::SdkError<
          28  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
          29  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          30  +
        >| {
          31  +
            err.map_service_error(|err| {
          32  +
                err.downcast::<crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError>()
          33  +
                    .expect("correct error type")
          34  +
            })
          35  +
        };
          36  +
        let context = Self::orchestrate_with_stop_point(runtime_plugins, input, ::aws_smithy_runtime::client::orchestrator::StopPoint::None)
          37  +
            .await
          38  +
            .map_err(map_err)?;
          39  +
        let output = context.finalize().map_err(map_err)?;
          40  +
        ::std::result::Result::Ok(
          41  +
            output
          42  +
                .downcast::<crate::operation::remove_tags_from_resource::RemoveTagsFromResourceOutput>()
          43  +
                .expect("correct output type"),
          44  +
        )
          45  +
    }
          46  +
          47  +
    pub(crate) async fn orchestrate_with_stop_point(
          48  +
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          49  +
        input: crate::operation::remove_tags_from_resource::RemoveTagsFromResourceInput,
          50  +
        stop_point: ::aws_smithy_runtime::client::orchestrator::StopPoint,
          51  +
    ) -> ::std::result::Result<
          52  +
        ::aws_smithy_runtime_api::client::interceptors::context::InterceptorContext,
          53  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          54  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
          55  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          56  +
        >,
          57  +
    > {
          58  +
        let input = ::aws_smithy_runtime_api::client::interceptors::context::Input::erase(input);
          59  +
        use ::tracing::Instrument;
          60  +
        ::aws_smithy_runtime::client::orchestrator::invoke_with_stop_point("SSM", "RemoveTagsFromResource", input, runtime_plugins, stop_point)
          61  +
            // Create a parent span for the entire operation. Includes a random, internal-only,
          62  +
            // seven-digit ID for the operation orchestration so that it can be correlated in the logs.
          63  +
            .instrument(::tracing::debug_span!(
          64  +
                "SSM.RemoveTagsFromResource",
          65  +
                "rpc.service" = "SSM",
          66  +
                "rpc.method" = "RemoveTagsFromResource",
          67  +
                "sdk_invocation_id" = ::fastrand::u32(1_000_000..10_000_000),
          68  +
                "rpc.system" = "aws-api",
          69  +
            ))
          70  +
            .await
          71  +
    }
          72  +
          73  +
    pub(crate) fn operation_runtime_plugins(
          74  +
        client_runtime_plugins: ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          75  +
        client_config: &crate::config::Config,
          76  +
        config_override: ::std::option::Option<crate::config::Builder>,
          77  +
    ) -> ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins {
          78  +
        let mut runtime_plugins = client_runtime_plugins.with_operation_plugin(Self::new());
          79  +
          80  +
        if let ::std::option::Option::Some(config_override) = config_override {
          81  +
            for plugin in config_override.runtime_plugins.iter().cloned() {
          82  +
                runtime_plugins = runtime_plugins.with_operation_plugin(plugin);
          83  +
            }
          84  +
            runtime_plugins = runtime_plugins.with_operation_plugin(crate::config::ConfigOverrideRuntimePlugin::new(
          85  +
                config_override,
          86  +
                client_config.config.clone(),
          87  +
                &client_config.runtime_components,
          88  +
            ));
          89  +
        }
          90  +
        runtime_plugins
          91  +
    }
          92  +
}
          93  +
/// Per-operation error registry. Contains an entry for every modeled
          94  +
/// error this operation can throw.
          95  +
///
          96  +
/// Used by the schema-serde error path as the operation-scoped lookup
          97  +
/// for registry-backed error reification: an error code that does not
          98  +
/// match one of the operation's modeled errors directly is resolved
          99  +
/// against this registry first, then widened to the service-wide error
         100  +
/// registry.
         101  +
pub(crate) mod error_registry {
         102  +
    pub(crate) static REGISTRY: ::std::sync::LazyLock<::aws_smithy_schema::registry::TypeRegistry> = ::std::sync::LazyLock::new(|| {
         103  +
        ::aws_smithy_schema::registry::TypeRegistry::builder()
         104  +
                            .insert_error_shape(
         105  +
                        crate::types::error::InternalServerError::SCHEMA,
         106  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         107  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InternalServerError::deserialize(d)?))
         108  +
                        },
         109  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         110  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InternalServerError::deserialize(d)?))
         111  +
                        },
         112  +
                    )
         113  +
.insert_error_shape(
         114  +
                        crate::types::error::InvalidResourceId::SCHEMA,
         115  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         116  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidResourceId::deserialize(d)?))
         117  +
                        },
         118  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         119  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidResourceId::deserialize(d)?))
         120  +
                        },
         121  +
                    )
         122  +
.insert_error_shape(
         123  +
                        crate::types::error::InvalidResourceType::SCHEMA,
         124  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         125  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::InvalidResourceType::deserialize(d)?))
         126  +
                        },
         127  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         128  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::InvalidResourceType::deserialize(d)?))
         129  +
                        },
         130  +
                    )
         131  +
.insert_error_shape(
         132  +
                        crate::types::error::TooManyUpdates::SCHEMA,
         133  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::aws_smithy_types::type_erasure::TypeErasedBox, ::aws_smithy_schema::serde::SerdeError> {
         134  +
                            ::std::result::Result::Ok(::aws_smithy_types::type_erasure::TypeErasedBox::new(crate::types::error::TooManyUpdates::deserialize(d)?))
         135  +
                        },
         136  +
                        |d: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer| -> ::std::result::Result<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync>, ::aws_smithy_schema::serde::SerdeError> {
         137  +
                            ::std::result::Result::Ok(::std::boxed::Box::new(crate::types::error::TooManyUpdates::deserialize(d)?))
         138  +
                        },
         139  +
                    )
         140  +
                            .build()
         141  +
    });
         142  +
}
         143  +
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for RemoveTagsFromResource {
         144  +
    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         145  +
        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("RemoveTagsFromResource");
         146  +
         147  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
         148  +
            RemoveTagsFromResourceRequestSerializer,
         149  +
        ));
         150  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
         151  +
            RemoveTagsFromResourceResponseDeserializer,
         152  +
        ));
         153  +
         154  +
        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
         155  +
            crate::config::auth::Params::builder()
         156  +
                .operation_name("RemoveTagsFromResource")
         157  +
                .build()
         158  +
                .expect("required fields set"),
         159  +
        ));
         160  +
         161  +
        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new(
         162  +
            "RemoveTagsFromResource",
         163  +
            "SSM",
         164  +
        ));
         165  +
        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         166  +
        signing_options.double_uri_encode = true;
         167  +
        signing_options.content_sha256_header = false;
         168  +
        signing_options.normalize_uri_path = true;
         169  +
        signing_options.payload_override = None;
         170  +
         171  +
        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
         172  +
            signing_options,
         173  +
            ..::std::default::Default::default()
         174  +
        });
         175  +
         176  +
        ::std::option::Option::Some(cfg.freeze())
         177  +
    }
         178  +
         179  +
    fn runtime_components(
         180  +
        &self,
         181  +
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
         182  +
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         183  +
        #[allow(unused_mut)]
         184  +
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("RemoveTagsFromResource")
         185  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         186  +
                RemoveTagsFromResourceTelemetryInputCaptureInterceptor,
         187  +
            ))
         188  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         189  +
                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
         190  +
            ))
         191  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         192  +
                RemoveTagsFromResourceEndpointParamsInterceptor,
         193  +
            ))
         194  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
         195  +
                crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
         196  +
            >::new())
         197  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
         198  +
                crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
         199  +
            >::new())
         200  +
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         201  +
                crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
         202  +
            >::new())
         203  +
            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
         204  +
                crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError,
         205  +
            >::new());
         206  +
         207  +
        ::std::borrow::Cow::Owned(rcb)
         208  +
    }
         209  +
}
         210  +
         211  +
#[derive(Debug)]
         212  +
struct RemoveTagsFromResourceTelemetryInputCaptureInterceptor;
         213  +
         214  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         215  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RemoveTagsFromResourceTelemetryInputCaptureInterceptor {
         216  +
    fn name(&self) -> &'static str {
         217  +
        "RemoveTagsFromResourceTelemetryInputCaptureInterceptor"
         218  +
    }
         219  +
         220  +
    fn read_before_execution(
         221  +
        &self,
         222  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         223  +
            '_,
         224  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         225  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         226  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         227  +
        >,
         228  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         229  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         230  +
        // Nothing to do unless the customer opted in by naming members to record.
         231  +
        let ::std::option::Option::Some(requested) = cfg
         232  +
            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
         233  +
            .filter(|r| !r.is_empty())
         234  +
        else {
         235  +
            return ::std::result::Result::Ok(());
         236  +
        };
         237  +
         238  +
        let ::std::option::Option::Some(input) = context.input().downcast_ref::<RemoveTagsFromResourceInput>() else {
         239  +
            // A mismatched input is not this interceptor's concern; skip quietly.
         240  +
            return ::std::result::Result::Ok(());
         241  +
        };
         242  +
         243  +
        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         244  +
        if requested.should_capture("ResourceId") {
         245  +
            if let ::std::option::Option::Some(value) = input.resource_id.as_deref() {
         246  +
                captured.insert("ResourceId", value);
         247  +
            }
         248  +
        }
         249  +
         250  +
        cfg.interceptor_state().store_put(captured);
         251  +
        ::std::result::Result::Ok(())
         252  +
    }
         253  +
}
         254  +
#[derive(Debug)]
         255  +
struct RemoveTagsFromResourceResponseDeserializer;
         256  +
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for RemoveTagsFromResourceResponseDeserializer {
         257  +
    fn deserialize_nonstreaming_with_config(
         258  +
        &self,
         259  +
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         260  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
         261  +
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         262  +
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         263  +
        // Load body and headers BEFORE BeforeParseResponse so customizations
         264  +
        // (e.g., S3's `body_is_error` check that detects errors returned with
         265  +
        // HTTP 200) can inspect them. The legacy non-streaming path also
         266  +
        // loads `body` before firing this hook.
         267  +
        let body = response.body().bytes().expect("body loaded");
         268  +
        let headers = response.headers();
         269  +
        #[allow(unused_mut)]
         270  +
        let mut force_error = false;
         271  +
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         272  +
        if !success && status != 200 || force_error {
         273  +
            let protocol = _cfg
         274  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         275  +
                .expect("a SharedClientProtocol is required");
         276  +
            #[allow(unused_mut)]
         277  +
            let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
         278  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         279  +
            })?;
         280  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         281  +
            let generic = generic_builder.build();
         282  +
            let error_code = match generic.code() {
         283  +
                ::std::option::Option::Some(code) => code,
         284  +
                ::std::option::Option::None => {
         285  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         286  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         287  +
                            crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::unhandled(generic),
         288  +
                        ),
         289  +
                    ))
         290  +
                }
         291  +
            };
         292  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         293  +
            let err = match error_code {
         294  +
                "InternalServerError" => crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InternalServerError({
         295  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         296  +
                        crate::types::error::InternalServerError::deserialize_with_response(
         297  +
                            &mut *deser,
         298  +
                            response.headers(),
         299  +
                            response.status().into(),
         300  +
                            body,
         301  +
                        )
         302  +
                    }) {
         303  +
                        ::std::result::Result::Ok(val) => val,
         304  +
                        ::std::result::Result::Err(e) => {
         305  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         306  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         307  +
                            ))
         308  +
                        }
         309  +
                    };
         310  +
                    tmp.meta = generic;
         311  +
                    if tmp.message.is_none() {
         312  +
                        tmp.message = _error_message;
         313  +
                    }
         314  +
                    tmp
         315  +
                }),
         316  +
                "InvalidResourceId" => crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InvalidResourceId({
         317  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         318  +
                        crate::types::error::InvalidResourceId::deserialize_with_response(
         319  +
                            &mut *deser,
         320  +
                            response.headers(),
         321  +
                            response.status().into(),
         322  +
                            body,
         323  +
                        )
         324  +
                    }) {
         325  +
                        ::std::result::Result::Ok(val) => val,
         326  +
                        ::std::result::Result::Err(e) => {
         327  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         328  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         329  +
                            ))
         330  +
                        }
         331  +
                    };
         332  +
                    tmp.meta = generic;
         333  +
                    if tmp.message.is_none() {
         334  +
                        tmp.message = _error_message;
         335  +
                    }
         336  +
                    tmp
         337  +
                }),
         338  +
                "InvalidResourceType" => crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::InvalidResourceType({
         339  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         340  +
                        crate::types::error::InvalidResourceType::deserialize_with_response(
         341  +
                            &mut *deser,
         342  +
                            response.headers(),
         343  +
                            response.status().into(),
         344  +
                            body,
         345  +
                        )
         346  +
                    }) {
         347  +
                        ::std::result::Result::Ok(val) => val,
         348  +
                        ::std::result::Result::Err(e) => {
         349  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         350  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         351  +
                            ))
         352  +
                        }
         353  +
                    };
         354  +
                    tmp.meta = generic;
         355  +
                    if tmp.message.is_none() {
         356  +
                        tmp.message = _error_message;
         357  +
                    }
         358  +
                    tmp
         359  +
                }),
         360  +
                "TooManyUpdates" => crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::TooManyUpdates({
         361  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         362  +
                        crate::types::error::TooManyUpdates::deserialize_with_response(
         363  +
                            &mut *deser,
         364  +
                            response.headers(),
         365  +
                            response.status().into(),
         366  +
                            body,
         367  +
                        )
         368  +
                    }) {
         369  +
                        ::std::result::Result::Ok(val) => val,
         370  +
                        ::std::result::Result::Err(e) => {
         371  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         372  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         373  +
                            ))
         374  +
                        }
         375  +
                    };
         376  +
                    tmp.meta = generic;
         377  +
                    if tmp.message.is_none() {
         378  +
                        tmp.message = _error_message;
         379  +
                    }
         380  +
                    tmp
         381  +
                }),
         382  +
                _ => {
         383  +
                    // Registry-backed, operation-scoped reification of an error whose
         384  +
                    // code this operation does not model directly: the operation's own
         385  +
                    // error registry is consulted first, then the lookup widens to the
         386  +
                    // service-wide error registry. On a hit, the reified error is attached
         387  +
                    // as the source of the returned unhandled error while its metadata
         388  +
                    // (code, message, request id) is preserved; on a miss the generic
         389  +
                    // error is returned unchanged.
         390  +
                    match protocol
         391  +
                        .deserialize_error_response(response, _cfg)
         392  +
                        .ok()
         393  +
                        .and_then(|mut deser| {
         394  +
                            ::aws_smithy_schema::registry::reify_error(
         395  +
                                crate::operation::remove_tags_from_resource::error_registry::REGISTRY
         396  +
                                    .or(&crate::error_type_registry::REGISTRY),
         397  +
                                error_code,
         398  +
                                &mut *deser,
         399  +
                            )
         400  +
                        }) {
         401  +
                        ::std::option::Option::Some(source) => <crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError as ::aws_smithy_runtime_api::client::result::CreateUnhandledError>::create_unhandled_error(source, ::std::option::Option::Some(generic)),
         402  +
                        ::std::option::Option::None => crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError::generic(generic),
         403  +
                    }
         404  +
                }
         405  +
            };
         406  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         407  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         408  +
            ))
         409  +
        } else {
         410  +
            let protocol = _cfg
         411  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         412  +
                .expect("a SharedClientProtocol is required");
         413  +
            let mut deser = protocol
         414  +
                .deserialize_response(response, RemoveTagsFromResource::OUTPUT_SCHEMA, _cfg)
         415  +
                .map_err(|e| {
         416  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         417  +
                })?;
         418  +
            // body and headers are already in scope from the top of the function;
         419  +
            // alias `headers` as `_response_headers` so MutateOutput
         420  +
            // customizations have a stable name to read from.
         421  +
            let _response_headers = headers;
         422  +
            #[allow(unused_mut)]
         423  +
            let mut output = crate::operation::remove_tags_from_resource::RemoveTagsFromResourceOutput::deserialize_with_response(
         424  +
                &mut *deser,
         425  +
                _response_headers,
         426  +
                response.status().into(),
         427  +
                body,
         428  +
            )
         429  +
            .map_err(|e| {
         430  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         431  +
            })?;
         432  +
            output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         433  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         434  +
        }
         435  +
    }
         436  +
}
         437  +
#[derive(Debug)]
         438  +
struct RemoveTagsFromResourceRequestSerializer;
         439  +
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for RemoveTagsFromResourceRequestSerializer {
         440  +
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
         441  +
    fn serialize_input(
         442  +
        &self,
         443  +
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         444  +
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         445  +
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         446  +
        let input = input
         447  +
            .downcast::<crate::operation::remove_tags_from_resource::RemoveTagsFromResourceInput>()
         448  +
            .expect("correct type");
         449  +
         450  +
        let protocol = _cfg
         451  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         452  +
            .expect("a SharedClientProtocol is required");
         453  +
        let mut request = protocol
         454  +
            .serialize_request(&input, RemoveTagsFromResource::INPUT_SCHEMA, "/", _cfg)
         455  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         456  +
         457  +
        return ::std::result::Result::Ok(request);
         458  +
    }
         459  +
}
         460  +
#[derive(Debug)]
         461  +
struct RemoveTagsFromResourceEndpointParamsInterceptor;
         462  +
         463  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         464  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for RemoveTagsFromResourceEndpointParamsInterceptor {
         465  +
    fn name(&self) -> &'static str {
         466  +
        "RemoveTagsFromResourceEndpointParamsInterceptor"
         467  +
    }
         468  +
         469  +
    fn read_before_execution(
         470  +
        &self,
         471  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         472  +
            '_,
         473  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         474  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         475  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         476  +
        >,
         477  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         478  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         479  +
        let _input = context
         480  +
            .input()
         481  +
            .downcast_ref::<RemoveTagsFromResourceInput>()
         482  +
            .ok_or("failed to downcast to RemoveTagsFromResourceInput")?;
         483  +
         484  +
        let params = crate::config::endpoint::Params::builder()
         485  +
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
         486  +
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
         487  +
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
         488  +
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
         489  +
            .build()
         490  +
            .map_err(|err| {
         491  +
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         492  +
            })?;
         493  +
        cfg.interceptor_state()
         494  +
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         495  +
        ::std::result::Result::Ok(())
         496  +
    }
         497  +
}
         498  +
         499  +
// The get_* functions below are generated from JMESPath expressions in the
         500  +
// operationContextParams trait. They target the operation's input shape.
         501  +
         502  +
/// Error type for the `RemoveTagsFromResourceError` operation.
         503  +
#[non_exhaustive]
         504  +
#[derive(::std::fmt::Debug)]
         505  +
pub enum RemoveTagsFromResourceError {
         506  +
    /// <p>An error occurred on the server side.</p>
         507  +
    InternalServerError(crate::types::error::InternalServerError),
         508  +
    /// <p>The resource ID isn't valid. Verify that you entered the correct ID and try again.</p>
         509  +
    InvalidResourceId(crate::types::error::InvalidResourceId),
         510  +
    /// <p>The resource type isn't valid. For example, if you are attempting to tag an EC2 instance, the instance must be a registered managed node.</p>
         511  +
    InvalidResourceType(crate::types::error::InvalidResourceType),
         512  +
    /// <p>There are concurrent updates for a resource that supports one update at a time.</p>
         513  +
    TooManyUpdates(crate::types::error::TooManyUpdates),
         514  +
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
         515  +
    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
         516  +
    variable wildcard pattern and check `.code()`:
         517  +
     \
         518  +
    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
         519  +
     \
         520  +
    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-RemoveTagsFromResourceError) for what information is available for the error.")]
         521  +
    Unhandled(crate::error::sealed_unhandled::Unhandled),
         522  +
}
         523  +
impl RemoveTagsFromResourceError {
         524  +
    /// Creates the `RemoveTagsFromResourceError::Unhandled` variant from any error type.
         525  +
    pub fn unhandled(
         526  +
        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
         527  +
    ) -> Self {
         528  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         529  +
            source: err.into(),
         530  +
            meta: ::std::default::Default::default(),
         531  +
        })
         532  +
    }
         533  +
         534  +
    /// Creates the `RemoveTagsFromResourceError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
         535  +
    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
         536  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         537  +
            source: err.clone().into(),
         538  +
            meta: err,
         539  +
        })
         540  +
    }
         541  +
    ///
         542  +
    /// Returns error metadata, which includes the error code, message,
         543  +
    /// request ID, and potentially additional information.
         544  +
    ///
         545  +
    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         546  +
        match self {
         547  +
            Self::InternalServerError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         548  +
            Self::InvalidResourceId(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         549  +
            Self::InvalidResourceType(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         550  +
            Self::TooManyUpdates(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         551  +
            Self::Unhandled(e) => &e.meta,
         552  +
        }
         553  +
    }
         554  +
    /// Returns `true` if the error kind is `RemoveTagsFromResourceError::InternalServerError`.
         555  +
    pub fn is_internal_server_error(&self) -> bool {
         556  +
        matches!(self, Self::InternalServerError(_))
         557  +
    }
         558  +
    /// Returns `true` if the error kind is `RemoveTagsFromResourceError::InvalidResourceId`.
         559  +
    pub fn is_invalid_resource_id(&self) -> bool {
         560  +
        matches!(self, Self::InvalidResourceId(_))
         561  +
    }
         562  +
    /// Returns `true` if the error kind is `RemoveTagsFromResourceError::InvalidResourceType`.
         563  +
    pub fn is_invalid_resource_type(&self) -> bool {
         564  +
        matches!(self, Self::InvalidResourceType(_))
         565  +
    }
         566  +
    /// Returns `true` if the error kind is `RemoveTagsFromResourceError::TooManyUpdates`.
         567  +
    pub fn is_too_many_updates(&self) -> bool {
         568  +
        matches!(self, Self::TooManyUpdates(_))
         569  +
    }
         570  +
}
         571  +
impl ::std::error::Error for RemoveTagsFromResourceError {
         572  +
    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         573  +
        match self {
         574  +
            Self::InternalServerError(_inner) => ::std::option::Option::Some(_inner),
         575  +
            Self::InvalidResourceId(_inner) => ::std::option::Option::Some(_inner),
         576  +
            Self::InvalidResourceType(_inner) => ::std::option::Option::Some(_inner),
         577  +
            Self::TooManyUpdates(_inner) => ::std::option::Option::Some(_inner),
         578  +
            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
         579  +
        }
         580  +
    }
         581  +
}
         582  +
impl ::std::fmt::Display for RemoveTagsFromResourceError {
         583  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         584  +
        match self {
         585  +
            Self::InternalServerError(_inner) => _inner.fmt(f),
         586  +
            Self::InvalidResourceId(_inner) => _inner.fmt(f),
         587  +
            Self::InvalidResourceType(_inner) => _inner.fmt(f),
         588  +
            Self::TooManyUpdates(_inner) => _inner.fmt(f),
         589  +
            Self::Unhandled(_inner) => {
         590  +
                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
         591  +
                    write!(f, "unhandled error ({code})")
         592  +
                } else {
         593  +
                    f.write_str("unhandled error")
         594  +
                }
         595  +
            }
         596  +
        }
         597  +
    }
         598  +
}
         599  +
impl ::aws_smithy_types::retry::ProvideErrorKind for RemoveTagsFromResourceError {
         600  +
    fn code(&self) -> ::std::option::Option<&str> {
         601  +
        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
         602  +
    }
         603  +
    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
         604  +
        ::std::option::Option::None
         605  +
    }
         606  +
}
         607  +
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for RemoveTagsFromResourceError {
         608  +
    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         609  +
        match self {
         610  +
            Self::InternalServerError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         611  +
            Self::InvalidResourceId(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         612  +
            Self::InvalidResourceType(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         613  +
            Self::TooManyUpdates(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         614  +
            Self::Unhandled(_inner) => &_inner.meta,
         615  +
        }
         616  +
    }
         617  +
}
         618  +
impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for RemoveTagsFromResourceError {
         619  +
    fn create_unhandled_error(
         620  +
        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
         621  +
        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
         622  +
    ) -> Self {
         623  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         624  +
            source,
         625  +
            meta: meta.unwrap_or_default(),
         626  +
        })
         627  +
    }
         628  +
}
         629  +
impl ::aws_types::request_id::RequestId for crate::operation::remove_tags_from_resource::RemoveTagsFromResourceError {
         630  +
    fn request_id(&self) -> Option<&str> {
         631  +
        self.meta().request_id()
         632  +
    }
         633  +
}
         634  +
         635  +
pub use crate::operation::remove_tags_from_resource::_remove_tags_from_resource_input::RemoveTagsFromResourceInput;
         636  +
         637  +
pub use crate::operation::remove_tags_from_resource::_remove_tags_from_resource_output::RemoveTagsFromResourceOutput;
         638  +
         639  +
mod _remove_tags_from_resource_input;
         640  +
         641  +
mod _remove_tags_from_resource_output;
         642  +
         643  +
/// Builders
         644  +
pub mod builders;