AWS SDK

AWS SDK

rev. 18b1dd205ff4335251e6dd0ecb88193de1b1cede (ignoring whitespace)

Files changed:

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

@@ -0,1 +0,131 @@
           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 DeleteActivationInput {
           6  +
    /// <p>The ID of the activation that you want to delete.</p>
           7  +
    pub activation_id: ::std::option::Option<::std::string::String>,
           8  +
}
           9  +
impl DeleteActivationInput {
          10  +
    /// <p>The ID of the activation that you want to delete.</p>
          11  +
    pub fn activation_id(&self) -> ::std::option::Option<&str> {
          12  +
        self.activation_id.as_deref()
          13  +
    }
          14  +
}
          15  +
static DELETEACTIVATIONINPUT_MEMBER_ACTIVATION_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          16  +
    ::aws_smithy_schema::ShapeId::from_parts(
          17  +
        "com.amazonaws.ssm.synthetic#DeleteActivationInput$ActivationId",
          18  +
        "com.amazonaws.ssm.synthetic",
          19  +
        "DeleteActivationInput",
          20  +
    ),
          21  +
    ::aws_smithy_schema::ShapeType::String,
          22  +
    "ActivationId",
          23  +
    0,
          24  +
);
          25  +
static DELETEACTIVATIONINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          26  +
    ::aws_smithy_schema::ShapeId::from_parts(
          27  +
        "com.amazonaws.ssm.synthetic#DeleteActivationInput",
          28  +
        "com.amazonaws.ssm.synthetic",
          29  +
        "DeleteActivationInput",
          30  +
    ),
          31  +
    ::aws_smithy_schema::ShapeType::Structure,
          32  +
    &[&DELETEACTIVATIONINPUT_MEMBER_ACTIVATION_ID],
          33  +
)
          34  +
.with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
          35  +
.with_original_name("DeleteActivationRequest");
          36  +
impl DeleteActivationInput {
          37  +
    /// The schema for this shape.
          38  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DELETEACTIVATIONINPUT_SCHEMA;
          39  +
}
          40  +
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteActivationInput {
          41  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          42  +
    fn serialize_members(
          43  +
        &self,
          44  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          45  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          46  +
        if let Some(ref val) = self.activation_id {
          47  +
            ser.write_string(&DELETEACTIVATIONINPUT_MEMBER_ACTIVATION_ID, val)?;
          48  +
        }
          49  +
        Ok(())
          50  +
    }
          51  +
}
          52  +
impl DeleteActivationInput {
          53  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          54  +
    pub fn deserialize(
          55  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          56  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          57  +
        #[allow(unused_variables, unused_mut)]
          58  +
        let mut builder = Self::builder();
          59  +
        #[allow(
          60  +
            unused_variables,
          61  +
            unreachable_code,
          62  +
            clippy::single_match,
          63  +
            clippy::match_single_binding,
          64  +
            clippy::diverging_sub_expression
          65  +
        )]
          66  +
        deserializer.read_struct(&DELETEACTIVATIONINPUT_SCHEMA, &mut |member, deser| {
          67  +
            match member.member_index() {
          68  +
                Some(0) => {
          69  +
                    if deser.is_null() {
          70  +
                        deser.read_null()?;
          71  +
                    } else {
          72  +
                        builder.activation_id = Some(deser.read_string(member)?);
          73  +
                    }
          74  +
                }
          75  +
                _ => {}
          76  +
            }
          77  +
            Ok(())
          78  +
        })?;
          79  +
        builder.activation_id = builder.activation_id.or(Some(String::new()));
          80  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
          81  +
    }
          82  +
}
          83  +
impl DeleteActivationInput {
          84  +
    /// Deserializes this structure from a body deserializer and HTTP response.
          85  +
    pub fn deserialize_with_response(
          86  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          87  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
          88  +
        _status: u16,
          89  +
        _body: &[u8],
          90  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          91  +
        Self::deserialize(deserializer)
          92  +
    }
          93  +
}
          94  +
impl DeleteActivationInput {
          95  +
    /// Creates a new builder-style object to manufacture [`DeleteActivationInput`](crate::operation::delete_activation::DeleteActivationInput).
          96  +
    pub fn builder() -> crate::operation::delete_activation::builders::DeleteActivationInputBuilder {
          97  +
        crate::operation::delete_activation::builders::DeleteActivationInputBuilder::default()
          98  +
    }
          99  +
}
         100  +
         101  +
/// A builder for [`DeleteActivationInput`](crate::operation::delete_activation::DeleteActivationInput).
         102  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         103  +
#[non_exhaustive]
         104  +
pub struct DeleteActivationInputBuilder {
         105  +
    pub(crate) activation_id: ::std::option::Option<::std::string::String>,
         106  +
}
         107  +
impl DeleteActivationInputBuilder {
         108  +
    /// <p>The ID of the activation that you want to delete.</p>
         109  +
    /// This field is required.
         110  +
    pub fn activation_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         111  +
        self.activation_id = ::std::option::Option::Some(input.into());
         112  +
        self
         113  +
    }
         114  +
    /// <p>The ID of the activation that you want to delete.</p>
         115  +
    pub fn set_activation_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         116  +
        self.activation_id = input;
         117  +
        self
         118  +
    }
         119  +
    /// <p>The ID of the activation that you want to delete.</p>
         120  +
    pub fn get_activation_id(&self) -> &::std::option::Option<::std::string::String> {
         121  +
        &self.activation_id
         122  +
    }
         123  +
    /// Consumes the builder and constructs a [`DeleteActivationInput`](crate::operation::delete_activation::DeleteActivationInput).
         124  +
    pub fn build(
         125  +
        self,
         126  +
    ) -> ::std::result::Result<crate::operation::delete_activation::DeleteActivationInput, ::aws_smithy_types::error::operation::BuildError> {
         127  +
        ::std::result::Result::Ok(crate::operation::delete_activation::DeleteActivationInput {
         128  +
            activation_id: self.activation_id,
         129  +
        })
         130  +
    }
         131  +
}

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

@@ -0,1 +0,122 @@
           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 DeleteActivationOutput {
           6  +
    _request_id: Option<String>,
           7  +
}
           8  +
static DELETEACTIVATIONOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
           9  +
    ::aws_smithy_schema::ShapeId::from_parts("synthetic#request_id", "synthetic", "request_id"),
          10  +
    ::aws_smithy_schema::ShapeType::String,
          11  +
    "request_id",
          12  +
    0,
          13  +
)
          14  +
.with_http_header("x-amzn-requestid");
          15  +
static DELETEACTIVATIONOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          16  +
    ::aws_smithy_schema::ShapeId::from_parts(
          17  +
        "com.amazonaws.ssm.synthetic#DeleteActivationOutput",
          18  +
        "com.amazonaws.ssm.synthetic",
          19  +
        "DeleteActivationOutput",
          20  +
    ),
          21  +
    ::aws_smithy_schema::ShapeType::Structure,
          22  +
    &[&DELETEACTIVATIONOUTPUT_MEMBER__REQUEST_ID],
          23  +
)
          24  +
.with_original_name("DeleteActivationResult");
          25  +
impl DeleteActivationOutput {
          26  +
    /// The schema for this shape.
          27  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DELETEACTIVATIONOUTPUT_SCHEMA;
          28  +
}
          29  +
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteActivationOutput {
          30  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          31  +
    fn serialize_members(
          32  +
        &self,
          33  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          34  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          35  +
        Ok(())
          36  +
    }
          37  +
}
          38  +
impl DeleteActivationOutput {
          39  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          40  +
    pub fn deserialize(
          41  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          42  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          43  +
        #[allow(unused_variables, unused_mut)]
          44  +
        let mut builder = Self::builder();
          45  +
        #[allow(
          46  +
            unused_variables,
          47  +
            unreachable_code,
          48  +
            clippy::single_match,
          49  +
            clippy::match_single_binding,
          50  +
            clippy::diverging_sub_expression
          51  +
        )]
          52  +
        deserializer.read_struct(&DELETEACTIVATIONOUTPUT_SCHEMA, &mut |member, deser| {
          53  +
            match member.member_index() {
          54  +
                Some(0) => {
          55  +
                    builder._request_id = Some(deser.read_string(member)?);
          56  +
                }
          57  +
                _ => {}
          58  +
            }
          59  +
            Ok(())
          60  +
        })?;
          61  +
        Ok(builder.build())
          62  +
    }
          63  +
}
          64  +
impl DeleteActivationOutput {
          65  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
          66  +
    /// Header-bound members are read directly from headers, avoiding runtime
          67  +
    /// member iteration overhead. Body members are read via the deserializer.
          68  +
    pub fn deserialize_with_response(
          69  +
        _deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          70  +
        headers: &::aws_smithy_runtime_api::http::Headers,
          71  +
        _status: u16,
          72  +
        _body: &[u8],
          73  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          74  +
        #[allow(unused_variables, unused_mut)]
          75  +
        let mut builder = Self::builder();
          76  +
        if let Some(val) = headers.get("x-amzn-requestid") {
          77  +
            builder._request_id = Some(val.to_string());
          78  +
        }
          79  +
        Ok(builder.build())
          80  +
    }
          81  +
}
          82  +
impl ::aws_types::request_id::RequestId for DeleteActivationOutput {
          83  +
    fn request_id(&self) -> Option<&str> {
          84  +
        self._request_id.as_deref()
          85  +
    }
          86  +
}
          87  +
impl DeleteActivationOutput {
          88  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
          89  +
        self._request_id = request_id;
          90  +
        self
          91  +
    }
          92  +
}
          93  +
impl DeleteActivationOutput {
          94  +
    /// Creates a new builder-style object to manufacture [`DeleteActivationOutput`](crate::operation::delete_activation::DeleteActivationOutput).
          95  +
    pub fn builder() -> crate::operation::delete_activation::builders::DeleteActivationOutputBuilder {
          96  +
        crate::operation::delete_activation::builders::DeleteActivationOutputBuilder::default()
          97  +
    }
          98  +
}
          99  +
         100  +
/// A builder for [`DeleteActivationOutput`](crate::operation::delete_activation::DeleteActivationOutput).
         101  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         102  +
#[non_exhaustive]
         103  +
pub struct DeleteActivationOutputBuilder {
         104  +
    _request_id: Option<String>,
         105  +
}
         106  +
impl DeleteActivationOutputBuilder {
         107  +
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         108  +
        self._request_id = Some(request_id.into());
         109  +
        self
         110  +
    }
         111  +
         112  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         113  +
        self._request_id = request_id;
         114  +
        self
         115  +
    }
         116  +
    /// Consumes the builder and constructs a [`DeleteActivationOutput`](crate::operation::delete_activation::DeleteActivationOutput).
         117  +
    pub fn build(self) -> crate::operation::delete_activation::DeleteActivationOutput {
         118  +
        crate::operation::delete_activation::DeleteActivationOutput {
         119  +
            _request_id: self._request_id,
         120  +
        }
         121  +
    }
         122  +
}

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

@@ -0,1 +0,125 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub use crate::operation::delete_activation::_delete_activation_input::DeleteActivationInputBuilder;
           3  +
           4  +
pub use crate::operation::delete_activation::_delete_activation_output::DeleteActivationOutputBuilder;
           5  +
           6  +
impl crate::operation::delete_activation::builders::DeleteActivationInputBuilder {
           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::delete_activation::DeleteActivationOutput,
          13  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          14  +
            crate::operation::delete_activation::DeleteActivationError,
          15  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          16  +
        >,
          17  +
    > {
          18  +
        let mut fluent_builder = client.delete_activation();
          19  +
        fluent_builder.inner = self;
          20  +
        fluent_builder.send().await
          21  +
    }
          22  +
}
          23  +
/// Fluent builder constructing a request to `DeleteActivation`.
          24  +
///
          25  +
/// <p>Deletes an activation. You aren't required to delete an activation. If you delete an activation, you can no longer use it to register additional managed nodes. Deleting an activation doesn't de-register managed nodes. You must manually de-register managed nodes.</p>
          26  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
          27  +
pub struct DeleteActivationFluentBuilder {
          28  +
    handle: ::std::sync::Arc<crate::client::Handle>,
          29  +
    inner: crate::operation::delete_activation::builders::DeleteActivationInputBuilder,
          30  +
    config_override: ::std::option::Option<crate::config::Builder>,
          31  +
}
          32  +
impl
          33  +
    crate::client::customize::internal::CustomizableSend<
          34  +
        crate::operation::delete_activation::DeleteActivationOutput,
          35  +
        crate::operation::delete_activation::DeleteActivationError,
          36  +
    > for DeleteActivationFluentBuilder
          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::delete_activation::DeleteActivationOutput,
          44  +
            crate::operation::delete_activation::DeleteActivationError,
          45  +
        >,
          46  +
    > {
          47  +
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
          48  +
    }
          49  +
}
          50  +
impl DeleteActivationFluentBuilder {
          51  +
    /// Creates a new `DeleteActivationFluentBuilder`.
          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 DeleteActivation as a reference.
          60  +
    pub fn as_input(&self) -> &crate::operation::delete_activation::builders::DeleteActivationInputBuilder {
          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::delete_activation::DeleteActivationOutput,
          75  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          76  +
            crate::operation::delete_activation::DeleteActivationError,
          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::delete_activation::DeleteActivation::operation_runtime_plugins(
          85  +
            self.handle.runtime_plugins.clone(),
          86  +
            &self.handle.conf,
          87  +
            self.config_override,
          88  +
        );
          89  +
        crate::operation::delete_activation::DeleteActivation::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::delete_activation::DeleteActivationOutput,
          97  +
        crate::operation::delete_activation::DeleteActivationError,
          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 activation that you want to delete.</p>
         112  +
    pub fn activation_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         113  +
        self.inner = self.inner.activation_id(input.into());
         114  +
        self
         115  +
    }
         116  +
    /// <p>The ID of the activation that you want to delete.</p>
         117  +
    pub fn set_activation_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         118  +
        self.inner = self.inner.set_activation_id(input);
         119  +
        self
         120  +
    }
         121  +
    /// <p>The ID of the activation that you want to delete.</p>
         122  +
    pub fn get_activation_id(&self) -> &::std::option::Option<::std::string::String> {
         123  +
        self.inner.get_activation_id()
         124  +
    }
         125  +
}

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

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