AWS SDK

AWS SDK

rev. 2915cec5ef64cb1ed4992565a748d76a11505b3b (ignoring whitespace)

Files changed:

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/delete_ops_item/_delete_ops_item_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 DeleteOpsItemOutput {
           6  +
    _request_id: Option<String>,
           7  +
}
           8  +
static DELETEOPSITEMOUTPUT_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 DELETEOPSITEMOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          16  +
    ::aws_smithy_schema::ShapeId::from_parts(
          17  +
        "com.amazonaws.ssm.synthetic#DeleteOpsItemOutput",
          18  +
        "com.amazonaws.ssm.synthetic",
          19  +
        "DeleteOpsItemOutput",
          20  +
    ),
          21  +
    ::aws_smithy_schema::ShapeType::Structure,
          22  +
    &[&DELETEOPSITEMOUTPUT_MEMBER__REQUEST_ID],
          23  +
)
          24  +
.with_original_name("DeleteOpsItemResponse");
          25  +
impl DeleteOpsItemOutput {
          26  +
    /// The schema for this shape.
          27  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DELETEOPSITEMOUTPUT_SCHEMA;
          28  +
}
          29  +
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteOpsItemOutput {
          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 DeleteOpsItemOutput {
          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(&DELETEOPSITEMOUTPUT_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 DeleteOpsItemOutput {
          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 DeleteOpsItemOutput {
          83  +
    fn request_id(&self) -> Option<&str> {
          84  +
        self._request_id.as_deref()
          85  +
    }
          86  +
}
          87  +
impl DeleteOpsItemOutput {
          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 DeleteOpsItemOutput {
          94  +
    /// Creates a new builder-style object to manufacture [`DeleteOpsItemOutput`](crate::operation::delete_ops_item::DeleteOpsItemOutput).
          95  +
    pub fn builder() -> crate::operation::delete_ops_item::builders::DeleteOpsItemOutputBuilder {
          96  +
        crate::operation::delete_ops_item::builders::DeleteOpsItemOutputBuilder::default()
          97  +
    }
          98  +
}
          99  +
         100  +
/// A builder for [`DeleteOpsItemOutput`](crate::operation::delete_ops_item::DeleteOpsItemOutput).
         101  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         102  +
#[non_exhaustive]
         103  +
pub struct DeleteOpsItemOutputBuilder {
         104  +
    _request_id: Option<String>,
         105  +
}
         106  +
impl DeleteOpsItemOutputBuilder {
         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 [`DeleteOpsItemOutput`](crate::operation::delete_ops_item::DeleteOpsItemOutput).
         117  +
    pub fn build(self) -> crate::operation::delete_ops_item::DeleteOpsItemOutput {
         118  +
        crate::operation::delete_ops_item::DeleteOpsItemOutput {
         119  +
            _request_id: self._request_id,
         120  +
        }
         121  +
    }
         122  +
}

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

@@ -0,1 +0,137 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub use crate::operation::delete_ops_item::_delete_ops_item_input::DeleteOpsItemInputBuilder;
           3  +
           4  +
pub use crate::operation::delete_ops_item::_delete_ops_item_output::DeleteOpsItemOutputBuilder;
           5  +
           6  +
impl crate::operation::delete_ops_item::builders::DeleteOpsItemInputBuilder {
           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_ops_item::DeleteOpsItemOutput,
          13  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          14  +
            crate::operation::delete_ops_item::DeleteOpsItemError,
          15  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          16  +
        >,
          17  +
    > {
          18  +
        let mut fluent_builder = client.delete_ops_item();
          19  +
        fluent_builder.inner = self;
          20  +
        fluent_builder.send().await
          21  +
    }
          22  +
}
          23  +
/// Fluent builder constructing a request to `DeleteOpsItem`.
          24  +
///
          25  +
/// <p>Delete an OpsItem. You must have permission in Identity and Access Management (IAM) to delete an OpsItem.</p><important>
          26  +
/// <p>Note the following important information about this operation.</p>
          27  +
/// <ul>
          28  +
/// <li>
          29  +
/// <p>Deleting an OpsItem is irreversible. You can't restore a deleted OpsItem.</p></li>
          30  +
/// <li>
          31  +
/// <p>This operation uses an <i>eventual consistency model</i>, which means the system can take a few minutes to complete this operation. If you delete an OpsItem and immediately call, for example, <code>GetOpsItem</code>, the deleted OpsItem might still appear in the response.</p></li>
          32  +
/// <li>
          33  +
/// <p>This operation is idempotent. The system doesn't throw an exception if you repeatedly call this operation for the same OpsItem. If the first call is successful, all additional calls return the same successful response as the first call.</p></li>
          34  +
/// <li>
          35  +
/// <p>This operation doesn't support cross-account calls. A delegated administrator or management account can't delete OpsItems in other accounts, even if OpsCenter has been set up for cross-account administration. For more information about cross-account administration, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/OpsCenter-setting-up-cross-account.html">Setting up OpsCenter to centrally manage OpsItems across accounts</a> in the <i>Systems Manager User Guide</i>.</p></li>
          36  +
/// </ul>
          37  +
/// </important>
          38  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
          39  +
pub struct DeleteOpsItemFluentBuilder {
          40  +
    handle: ::std::sync::Arc<crate::client::Handle>,
          41  +
    inner: crate::operation::delete_ops_item::builders::DeleteOpsItemInputBuilder,
          42  +
    config_override: ::std::option::Option<crate::config::Builder>,
          43  +
}
          44  +
impl
          45  +
    crate::client::customize::internal::CustomizableSend<
          46  +
        crate::operation::delete_ops_item::DeleteOpsItemOutput,
          47  +
        crate::operation::delete_ops_item::DeleteOpsItemError,
          48  +
    > for DeleteOpsItemFluentBuilder
          49  +
{
          50  +
    fn send(
          51  +
        self,
          52  +
        config_override: crate::config::Builder,
          53  +
    ) -> crate::client::customize::internal::BoxFuture<
          54  +
        crate::client::customize::internal::SendResult<
          55  +
            crate::operation::delete_ops_item::DeleteOpsItemOutput,
          56  +
            crate::operation::delete_ops_item::DeleteOpsItemError,
          57  +
        >,
          58  +
    > {
          59  +
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
          60  +
    }
          61  +
}
          62  +
impl DeleteOpsItemFluentBuilder {
          63  +
    /// Creates a new `DeleteOpsItemFluentBuilder`.
          64  +
    pub(crate) fn new(handle: ::std::sync::Arc<crate::client::Handle>) -> Self {
          65  +
        Self {
          66  +
            handle,
          67  +
            inner: ::std::default::Default::default(),
          68  +
            config_override: ::std::option::Option::None,
          69  +
        }
          70  +
    }
          71  +
    /// Access the DeleteOpsItem as a reference.
          72  +
    pub fn as_input(&self) -> &crate::operation::delete_ops_item::builders::DeleteOpsItemInputBuilder {
          73  +
        &self.inner
          74  +
    }
          75  +
    /// Sends the request and returns the response.
          76  +
    ///
          77  +
    /// If an error occurs, an `SdkError` will be returned with additional details that
          78  +
    /// can be matched against.
          79  +
    ///
          80  +
    /// By default, any retryable failures will be retried twice. Retry behavior
          81  +
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
          82  +
    /// set when configuring the client.
          83  +
    pub async fn send(
          84  +
        self,
          85  +
    ) -> ::std::result::Result<
          86  +
        crate::operation::delete_ops_item::DeleteOpsItemOutput,
          87  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          88  +
            crate::operation::delete_ops_item::DeleteOpsItemError,
          89  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          90  +
        >,
          91  +
    > {
          92  +
        let input = self
          93  +
            .inner
          94  +
            .build()
          95  +
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
          96  +
        let runtime_plugins = crate::operation::delete_ops_item::DeleteOpsItem::operation_runtime_plugins(
          97  +
            self.handle.runtime_plugins.clone(),
          98  +
            &self.handle.conf,
          99  +
            self.config_override,
         100  +
        );
         101  +
        crate::operation::delete_ops_item::DeleteOpsItem::orchestrate(&runtime_plugins, input).await
         102  +
    }
         103  +
         104  +
    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
         105  +
    pub fn customize(
         106  +
        self,
         107  +
    ) -> crate::client::customize::CustomizableOperation<
         108  +
        crate::operation::delete_ops_item::DeleteOpsItemOutput,
         109  +
        crate::operation::delete_ops_item::DeleteOpsItemError,
         110  +
        Self,
         111  +
    > {
         112  +
        crate::client::customize::CustomizableOperation::new(self)
         113  +
    }
         114  +
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         115  +
        self.set_config_override(::std::option::Option::Some(config_override.into()));
         116  +
        self
         117  +
    }
         118  +
         119  +
    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         120  +
        self.config_override = config_override;
         121  +
        self
         122  +
    }
         123  +
    /// <p>The ID of the OpsItem that you want to delete.</p>
         124  +
    pub fn ops_item_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         125  +
        self.inner = self.inner.ops_item_id(input.into());
         126  +
        self
         127  +
    }
         128  +
    /// <p>The ID of the OpsItem that you want to delete.</p>
         129  +
    pub fn set_ops_item_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         130  +
        self.inner = self.inner.set_ops_item_id(input);
         131  +
        self
         132  +
    }
         133  +
    /// <p>The ID of the OpsItem that you want to delete.</p>
         134  +
    pub fn get_ops_item_id(&self) -> &::std::option::Option<::std::string::String> {
         135  +
        self.inner.get_ops_item_id()
         136  +
    }
         137  +
}

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

@@ -0,1 +0,600 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/// Orchestration and serialization glue logic for `DeleteOpsMetadata`.
           3  +
#[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
           4  +
#[non_exhaustive]
           5  +
pub struct DeleteOpsMetadata;
           6  +
impl DeleteOpsMetadata {
           7  +
    /// Creates a new `DeleteOpsMetadata`
           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_ops_metadata::DeleteOpsMetadataInput::SCHEMA;
          13  +
    /// The schema for this operation's output shape.
          14  +
    pub const OUTPUT_SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput::SCHEMA;
          15  +
    pub(crate) async fn orchestrate(
          16  +
        runtime_plugins: &::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugins,
          17  +
        input: crate::operation::delete_ops_metadata::DeleteOpsMetadataInput,
          18  +
    ) -> ::std::result::Result<
          19  +
        crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput,
          20  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          21  +
            crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
          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_ops_metadata::DeleteOpsMetadataError>()
          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_ops_metadata::DeleteOpsMetadataOutput>()
          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_ops_metadata::DeleteOpsMetadataInput,
          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", "DeleteOpsMetadata", 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.DeleteOpsMetadata",
          63  +
                "rpc.service" = "SSM",
          64  +
                "rpc.method" = "DeleteOpsMetadata",
          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::InternalServerError::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::InternalServerError::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::InternalServerError::deserialize(d)?))
         109  +
                        },
         110  +
                    )
         111  +
.insert_error_shape(
         112  +
                        crate::types::error::OpsMetadataInvalidArgumentException::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::OpsMetadataInvalidArgumentException::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::OpsMetadataInvalidArgumentException::deserialize(d)?))
         118  +
                        },
         119  +
                    )
         120  +
.insert_error_shape(
         121  +
                        crate::types::error::OpsMetadataNotFoundException::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::OpsMetadataNotFoundException::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::OpsMetadataNotFoundException::deserialize(d)?))
         127  +
                        },
         128  +
                    )
         129  +
                            .build()
         130  +
    });
         131  +
}
         132  +
impl ::aws_smithy_runtime_api::client::runtime_plugin::RuntimePlugin for DeleteOpsMetadata {
         133  +
    fn config(&self) -> ::std::option::Option<::aws_smithy_types::config_bag::FrozenLayer> {
         134  +
        let mut cfg = ::aws_smithy_types::config_bag::Layer::new("DeleteOpsMetadata");
         135  +
         136  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedRequestSerializer::new(
         137  +
            DeleteOpsMetadataRequestSerializer,
         138  +
        ));
         139  +
        cfg.store_put(::aws_smithy_runtime_api::client::ser_de::SharedResponseDeserializer::new(
         140  +
            DeleteOpsMetadataResponseDeserializer,
         141  +
        ));
         142  +
         143  +
        cfg.store_put(::aws_smithy_runtime_api::client::auth::AuthSchemeOptionResolverParams::new(
         144  +
            crate::config::auth::Params::builder()
         145  +
                .operation_name("DeleteOpsMetadata")
         146  +
                .build()
         147  +
                .expect("required fields set"),
         148  +
        ));
         149  +
         150  +
        cfg.store_put(::aws_smithy_runtime_api::client::orchestrator::Metadata::new("DeleteOpsMetadata", "SSM"));
         151  +
        let mut signing_options = ::aws_runtime::auth::SigningOptions::default();
         152  +
        signing_options.double_uri_encode = true;
         153  +
        signing_options.content_sha256_header = false;
         154  +
        signing_options.normalize_uri_path = true;
         155  +
        signing_options.payload_override = None;
         156  +
         157  +
        cfg.store_put(::aws_runtime::auth::SigV4OperationSigningConfig {
         158  +
            signing_options,
         159  +
            ..::std::default::Default::default()
         160  +
        });
         161  +
         162  +
        ::std::option::Option::Some(cfg.freeze())
         163  +
    }
         164  +
         165  +
    fn runtime_components(
         166  +
        &self,
         167  +
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
         168  +
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
         169  +
        #[allow(unused_mut)]
         170  +
        let mut rcb = ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder::new("DeleteOpsMetadata")
         171  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         172  +
                DeleteOpsMetadataTelemetryInputCaptureInterceptor,
         173  +
            ))
         174  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         175  +
                ::aws_smithy_runtime::client::stalled_stream_protection::StalledStreamProtectionInterceptor::default(),
         176  +
            ))
         177  +
            .with_interceptor(::aws_smithy_runtime_api::client::interceptors::SharedInterceptor::permanent(
         178  +
                DeleteOpsMetadataEndpointParamsInterceptor,
         179  +
            ))
         180  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::TransientErrorClassifier::<
         181  +
                crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
         182  +
            >::new())
         183  +
            .with_retry_classifier(::aws_smithy_runtime::client::retries::classifiers::ModeledAsRetryableClassifier::<
         184  +
                crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
         185  +
            >::new())
         186  +
            .with_retry_classifier(::aws_runtime::retries::classifiers::AwsErrorCodeClassifier::<
         187  +
                crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
         188  +
            >::new())
         189  +
            .with_retry_classifier(::aws_runtime::service_clock_skew::ServiceClockSkewClassifier::<
         190  +
                crate::operation::delete_ops_metadata::DeleteOpsMetadataError,
         191  +
            >::new());
         192  +
         193  +
        ::std::borrow::Cow::Owned(rcb)
         194  +
    }
         195  +
}
         196  +
         197  +
#[derive(Debug)]
         198  +
struct DeleteOpsMetadataTelemetryInputCaptureInterceptor;
         199  +
         200  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         201  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteOpsMetadataTelemetryInputCaptureInterceptor {
         202  +
    fn name(&self) -> &'static str {
         203  +
        "DeleteOpsMetadataTelemetryInputCaptureInterceptor"
         204  +
    }
         205  +
         206  +
    fn read_before_execution(
         207  +
        &self,
         208  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         209  +
            '_,
         210  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         211  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         212  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         213  +
        >,
         214  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         215  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         216  +
        // Nothing to do unless the customer opted in by naming members to record.
         217  +
        let ::std::option::Option::Some(requested) = cfg
         218  +
            .load::<::aws_smithy_types::telemetry::RequestedTelemetryAttributes>()
         219  +
            .filter(|r| !r.is_empty())
         220  +
        else {
         221  +
            return ::std::result::Result::Ok(());
         222  +
        };
         223  +
         224  +
        let ::std::option::Option::Some(input) = context.input().downcast_ref::<DeleteOpsMetadataInput>() else {
         225  +
            // A mismatched input is not this interceptor's concern; skip quietly.
         226  +
            return ::std::result::Result::Ok(());
         227  +
        };
         228  +
         229  +
        let mut captured = ::aws_smithy_types::telemetry::CapturedTelemetryAttributes::default();
         230  +
        if requested.should_capture("OpsMetadataArn") {
         231  +
            if let ::std::option::Option::Some(value) = input.ops_metadata_arn.as_deref() {
         232  +
                captured.insert("OpsMetadataArn", value);
         233  +
            }
         234  +
        }
         235  +
         236  +
        cfg.interceptor_state().store_put(captured);
         237  +
        ::std::result::Result::Ok(())
         238  +
    }
         239  +
}
         240  +
#[derive(Debug)]
         241  +
struct DeleteOpsMetadataResponseDeserializer;
         242  +
impl ::aws_smithy_runtime_api::client::ser_de::DeserializeResponse for DeleteOpsMetadataResponseDeserializer {
         243  +
    fn deserialize_nonstreaming_with_config(
         244  +
        &self,
         245  +
        response: &::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
         246  +
        _cfg: &::aws_smithy_types::config_bag::ConfigBag,
         247  +
    ) -> ::aws_smithy_runtime_api::client::interceptors::context::OutputOrError {
         248  +
        let (success, status) = (response.status().is_success(), response.status().as_u16());
         249  +
        // Load body and headers BEFORE BeforeParseResponse so customizations
         250  +
        // (e.g., S3's `body_is_error` check that detects errors returned with
         251  +
        // HTTP 200) can inspect them. The legacy non-streaming path also
         252  +
        // loads `body` before firing this hook.
         253  +
        let body = response.body().bytes().expect("body loaded");
         254  +
        let headers = response.headers();
         255  +
        #[allow(unused_mut)]
         256  +
        let mut force_error = false;
         257  +
        ::tracing::debug!(request_id = ?::aws_types::request_id::RequestId::request_id(response));
         258  +
        if !success && status != 200 || force_error {
         259  +
            let protocol = _cfg
         260  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         261  +
                .expect("a SharedClientProtocol is required");
         262  +
            #[allow(unused_mut)]
         263  +
            let mut generic_builder = protocol.parse_error_metadata(response, _cfg).map_err(|e| {
         264  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         265  +
            })?;
         266  +
            generic_builder = ::aws_types::request_id::apply_request_id(generic_builder, headers);
         267  +
            let generic = generic_builder.build();
         268  +
            let error_code = match generic.code() {
         269  +
                ::std::option::Option::Some(code) => code,
         270  +
                ::std::option::Option::None => {
         271  +
                    return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         272  +
                        ::aws_smithy_runtime_api::box_error::BoxError::from(
         273  +
                            crate::operation::delete_ops_metadata::DeleteOpsMetadataError::unhandled(generic),
         274  +
                        ),
         275  +
                    ))
         276  +
                }
         277  +
            };
         278  +
            let _error_message = generic.message().map(|msg| msg.to_owned());
         279  +
            let err = match error_code {
         280  +
                "InternalServerError" => crate::operation::delete_ops_metadata::DeleteOpsMetadataError::InternalServerError({
         281  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         282  +
                        crate::types::error::InternalServerError::deserialize_with_response(
         283  +
                            &mut *deser,
         284  +
                            response.headers(),
         285  +
                            response.status().into(),
         286  +
                            body,
         287  +
                        )
         288  +
                    }) {
         289  +
                        ::std::result::Result::Ok(val) => val,
         290  +
                        ::std::result::Result::Err(e) => {
         291  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         292  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         293  +
                            ))
         294  +
                        }
         295  +
                    };
         296  +
                    tmp.meta = generic;
         297  +
                    if tmp.message.is_none() {
         298  +
                        tmp.message = _error_message;
         299  +
                    }
         300  +
                    tmp
         301  +
                }),
         302  +
                "OpsMetadataInvalidArgumentException" => {
         303  +
                    crate::operation::delete_ops_metadata::DeleteOpsMetadataError::OpsMetadataInvalidArgumentException({
         304  +
                        let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         305  +
                            crate::types::error::OpsMetadataInvalidArgumentException::deserialize_with_response(
         306  +
                                &mut *deser,
         307  +
                                response.headers(),
         308  +
                                response.status().into(),
         309  +
                                body,
         310  +
                            )
         311  +
                        }) {
         312  +
                            ::std::result::Result::Ok(val) => val,
         313  +
                            ::std::result::Result::Err(e) => {
         314  +
                                return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         315  +
                                    ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         316  +
                                ))
         317  +
                            }
         318  +
                        };
         319  +
                        tmp.meta = generic;
         320  +
                        if tmp.message.is_none() {
         321  +
                            tmp.message = _error_message;
         322  +
                        }
         323  +
                        tmp
         324  +
                    })
         325  +
                }
         326  +
                "OpsMetadataNotFoundException" => crate::operation::delete_ops_metadata::DeleteOpsMetadataError::OpsMetadataNotFoundException({
         327  +
                    let mut tmp = match protocol.deserialize_error_response(response, _cfg).and_then(|mut deser| {
         328  +
                        crate::types::error::OpsMetadataNotFoundException::deserialize_with_response(
         329  +
                            &mut *deser,
         330  +
                            response.headers(),
         331  +
                            response.status().into(),
         332  +
                            body,
         333  +
                        )
         334  +
                    }) {
         335  +
                        ::std::result::Result::Ok(val) => val,
         336  +
                        ::std::result::Result::Err(e) => {
         337  +
                            return ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(
         338  +
                                ::aws_smithy_runtime_api::box_error::BoxError::from(e),
         339  +
                            ))
         340  +
                        }
         341  +
                    };
         342  +
                    tmp.meta = generic;
         343  +
                    if tmp.message.is_none() {
         344  +
                        tmp.message = _error_message;
         345  +
                    }
         346  +
                    tmp
         347  +
                }),
         348  +
                _ => {
         349  +
                    // Registry-backed, operation-scoped reification of an error whose
         350  +
                    // code this operation does not model directly: the operation's own
         351  +
                    // error registry is consulted first, then the lookup widens to the
         352  +
                    // service-wide error registry. On a hit, the reified error is attached
         353  +
                    // as the source of the returned unhandled error while its metadata
         354  +
                    // (code, message, request id) is preserved; on a miss the generic
         355  +
                    // error is returned unchanged.
         356  +
                    match protocol
         357  +
                        .deserialize_error_response(response, _cfg)
         358  +
                        .ok()
         359  +
                        .and_then(|mut deser| {
         360  +
                            ::aws_smithy_schema::registry::reify_error(
         361  +
                                crate::operation::delete_ops_metadata::error_registry::REGISTRY
         362  +
                                    .or(&crate::error_type_registry::REGISTRY),
         363  +
                                error_code,
         364  +
                                &mut *deser,
         365  +
                            )
         366  +
                        }) {
         367  +
                        ::std::option::Option::Some(source) => <crate::operation::delete_ops_metadata::DeleteOpsMetadataError as ::aws_smithy_runtime_api::client::result::CreateUnhandledError>::create_unhandled_error(source, ::std::option::Option::Some(generic)),
         368  +
                        ::std::option::Option::None => crate::operation::delete_ops_metadata::DeleteOpsMetadataError::generic(generic),
         369  +
                    }
         370  +
                }
         371  +
            };
         372  +
            ::std::result::Result::Err(::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::operation(
         373  +
                ::aws_smithy_runtime_api::client::interceptors::context::Error::erase(err),
         374  +
            ))
         375  +
        } else {
         376  +
            let protocol = _cfg
         377  +
                .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         378  +
                .expect("a SharedClientProtocol is required");
         379  +
            let mut deser = protocol
         380  +
                .deserialize_response(response, DeleteOpsMetadata::OUTPUT_SCHEMA, _cfg)
         381  +
                .map_err(|e| {
         382  +
                    ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         383  +
                })?;
         384  +
            // body and headers are already in scope from the top of the function;
         385  +
            // alias `headers` as `_response_headers` so MutateOutput
         386  +
            // customizations have a stable name to read from.
         387  +
            let _response_headers = headers;
         388  +
            #[allow(unused_mut)]
         389  +
            let mut output = crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput::deserialize_with_response(
         390  +
                &mut *deser,
         391  +
                _response_headers,
         392  +
                response.status().into(),
         393  +
                body,
         394  +
            )
         395  +
            .map_err(|e| {
         396  +
                ::aws_smithy_runtime_api::client::orchestrator::OrchestratorError::other(::aws_smithy_runtime_api::box_error::BoxError::from(e))
         397  +
            })?;
         398  +
            output._set_request_id(::aws_types::request_id::RequestId::request_id(_response_headers).map(str::to_string));
         399  +
            ::std::result::Result::Ok(::aws_smithy_runtime_api::client::interceptors::context::Output::erase(output))
         400  +
        }
         401  +
    }
         402  +
}
         403  +
#[derive(Debug)]
         404  +
struct DeleteOpsMetadataRequestSerializer;
         405  +
impl ::aws_smithy_runtime_api::client::ser_de::SerializeRequest for DeleteOpsMetadataRequestSerializer {
         406  +
    #[allow(unused_mut, clippy::let_and_return, clippy::needless_borrow, clippy::useless_conversion)]
         407  +
    fn serialize_input(
         408  +
        &self,
         409  +
        input: ::aws_smithy_runtime_api::client::interceptors::context::Input,
         410  +
        _cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         411  +
    ) -> ::std::result::Result<::aws_smithy_runtime_api::client::orchestrator::HttpRequest, ::aws_smithy_runtime_api::box_error::BoxError> {
         412  +
        let input = input
         413  +
            .downcast::<crate::operation::delete_ops_metadata::DeleteOpsMetadataInput>()
         414  +
            .expect("correct type");
         415  +
         416  +
        let protocol = _cfg
         417  +
            .load::<::aws_smithy_schema::protocol::SharedClientProtocol>()
         418  +
            .expect("a SharedClientProtocol is required");
         419  +
        let mut request = protocol
         420  +
            .serialize_request(&input, DeleteOpsMetadata::INPUT_SCHEMA, "/", _cfg)
         421  +
            .map_err(::aws_smithy_runtime_api::box_error::BoxError::from)?;
         422  +
         423  +
        return ::std::result::Result::Ok(request);
         424  +
    }
         425  +
}
         426  +
#[derive(Debug)]
         427  +
struct DeleteOpsMetadataEndpointParamsInterceptor;
         428  +
         429  +
#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
         430  +
impl ::aws_smithy_runtime_api::client::interceptors::Intercept for DeleteOpsMetadataEndpointParamsInterceptor {
         431  +
    fn name(&self) -> &'static str {
         432  +
        "DeleteOpsMetadataEndpointParamsInterceptor"
         433  +
    }
         434  +
         435  +
    fn read_before_execution(
         436  +
        &self,
         437  +
        context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<
         438  +
            '_,
         439  +
            ::aws_smithy_runtime_api::client::interceptors::context::Input,
         440  +
            ::aws_smithy_runtime_api::client::interceptors::context::Output,
         441  +
            ::aws_smithy_runtime_api::client::interceptors::context::Error,
         442  +
        >,
         443  +
        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
         444  +
    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
         445  +
        let _input = context
         446  +
            .input()
         447  +
            .downcast_ref::<DeleteOpsMetadataInput>()
         448  +
            .ok_or("failed to downcast to DeleteOpsMetadataInput")?;
         449  +
         450  +
        let params = crate::config::endpoint::Params::builder()
         451  +
            .set_region(cfg.load::<::aws_types::region::Region>().map(|r| r.as_ref().to_owned()))
         452  +
            .set_use_dual_stack(cfg.load::<::aws_types::endpoint_config::UseDualStack>().map(|ty| ty.0))
         453  +
            .set_use_fips(cfg.load::<::aws_types::endpoint_config::UseFips>().map(|ty| ty.0))
         454  +
            .set_endpoint(cfg.load::<::aws_types::endpoint_config::EndpointUrl>().map(|ty| ty.0.clone()))
         455  +
            .build()
         456  +
            .map_err(|err| {
         457  +
                ::aws_smithy_runtime_api::client::interceptors::error::ContextAttachedError::new("endpoint params could not be built", err)
         458  +
            })?;
         459  +
        cfg.interceptor_state()
         460  +
            .store_put(::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams::new(params));
         461  +
        ::std::result::Result::Ok(())
         462  +
    }
         463  +
}
         464  +
         465  +
// The get_* functions below are generated from JMESPath expressions in the
         466  +
// operationContextParams trait. They target the operation's input shape.
         467  +
         468  +
/// Error type for the `DeleteOpsMetadataError` operation.
         469  +
#[non_exhaustive]
         470  +
#[derive(::std::fmt::Debug)]
         471  +
pub enum DeleteOpsMetadataError {
         472  +
    /// <p>An error occurred on the server side.</p>
         473  +
    InternalServerError(crate::types::error::InternalServerError),
         474  +
    /// <p>One of the arguments passed is invalid.</p>
         475  +
    OpsMetadataInvalidArgumentException(crate::types::error::OpsMetadataInvalidArgumentException),
         476  +
    /// <p>The OpsMetadata object doesn't exist.</p>
         477  +
    OpsMetadataNotFoundException(crate::types::error::OpsMetadataNotFoundException),
         478  +
    /// An unexpected error occurred (e.g., invalid JSON returned by the service or an unknown error code).
         479  +
    #[deprecated(note = "Matching `Unhandled` directly is not forwards compatible. Instead, match using a \
         480  +
    variable wildcard pattern and check `.code()`:
         481  +
     \
         482  +
    &nbsp;&nbsp;&nbsp;`err if err.code() == Some(\"SpecificExceptionCode\") => { /* handle the error */ }`
         483  +
     \
         484  +
    See [`ProvideErrorMetadata`](#impl-ProvideErrorMetadata-for-DeleteOpsMetadataError) for what information is available for the error.")]
         485  +
    Unhandled(crate::error::sealed_unhandled::Unhandled),
         486  +
}
         487  +
impl DeleteOpsMetadataError {
         488  +
    /// Creates the `DeleteOpsMetadataError::Unhandled` variant from any error type.
         489  +
    pub fn unhandled(
         490  +
        err: impl ::std::convert::Into<::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>>,
         491  +
    ) -> Self {
         492  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         493  +
            source: err.into(),
         494  +
            meta: ::std::default::Default::default(),
         495  +
        })
         496  +
    }
         497  +
         498  +
    /// Creates the `DeleteOpsMetadataError::Unhandled` variant from an [`ErrorMetadata`](::aws_smithy_types::error::ErrorMetadata).
         499  +
    pub fn generic(err: ::aws_smithy_types::error::ErrorMetadata) -> Self {
         500  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         501  +
            source: err.clone().into(),
         502  +
            meta: err,
         503  +
        })
         504  +
    }
         505  +
    ///
         506  +
    /// Returns error metadata, which includes the error code, message,
         507  +
    /// request ID, and potentially additional information.
         508  +
    ///
         509  +
    pub fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         510  +
        match self {
         511  +
            Self::InternalServerError(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         512  +
            Self::OpsMetadataInvalidArgumentException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         513  +
            Self::OpsMetadataNotFoundException(e) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(e),
         514  +
            Self::Unhandled(e) => &e.meta,
         515  +
        }
         516  +
    }
         517  +
    /// Returns `true` if the error kind is `DeleteOpsMetadataError::InternalServerError`.
         518  +
    pub fn is_internal_server_error(&self) -> bool {
         519  +
        matches!(self, Self::InternalServerError(_))
         520  +
    }
         521  +
    /// Returns `true` if the error kind is `DeleteOpsMetadataError::OpsMetadataInvalidArgumentException`.
         522  +
    pub fn is_ops_metadata_invalid_argument_exception(&self) -> bool {
         523  +
        matches!(self, Self::OpsMetadataInvalidArgumentException(_))
         524  +
    }
         525  +
    /// Returns `true` if the error kind is `DeleteOpsMetadataError::OpsMetadataNotFoundException`.
         526  +
    pub fn is_ops_metadata_not_found_exception(&self) -> bool {
         527  +
        matches!(self, Self::OpsMetadataNotFoundException(_))
         528  +
    }
         529  +
}
         530  +
impl ::std::error::Error for DeleteOpsMetadataError {
         531  +
    fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
         532  +
        match self {
         533  +
            Self::InternalServerError(_inner) => ::std::option::Option::Some(_inner),
         534  +
            Self::OpsMetadataInvalidArgumentException(_inner) => ::std::option::Option::Some(_inner),
         535  +
            Self::OpsMetadataNotFoundException(_inner) => ::std::option::Option::Some(_inner),
         536  +
            Self::Unhandled(_inner) => ::std::option::Option::Some(&*_inner.source),
         537  +
        }
         538  +
    }
         539  +
}
         540  +
impl ::std::fmt::Display for DeleteOpsMetadataError {
         541  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         542  +
        match self {
         543  +
            Self::InternalServerError(_inner) => _inner.fmt(f),
         544  +
            Self::OpsMetadataInvalidArgumentException(_inner) => _inner.fmt(f),
         545  +
            Self::OpsMetadataNotFoundException(_inner) => _inner.fmt(f),
         546  +
            Self::Unhandled(_inner) => {
         547  +
                if let ::std::option::Option::Some(code) = ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self) {
         548  +
                    write!(f, "unhandled error ({code})")
         549  +
                } else {
         550  +
                    f.write_str("unhandled error")
         551  +
                }
         552  +
            }
         553  +
        }
         554  +
    }
         555  +
}
         556  +
impl ::aws_smithy_types::retry::ProvideErrorKind for DeleteOpsMetadataError {
         557  +
    fn code(&self) -> ::std::option::Option<&str> {
         558  +
        ::aws_smithy_types::error::metadata::ProvideErrorMetadata::code(self)
         559  +
    }
         560  +
    fn retryable_error_kind(&self) -> ::std::option::Option<::aws_smithy_types::retry::ErrorKind> {
         561  +
        ::std::option::Option::None
         562  +
    }
         563  +
}
         564  +
impl ::aws_smithy_types::error::metadata::ProvideErrorMetadata for DeleteOpsMetadataError {
         565  +
    fn meta(&self) -> &::aws_smithy_types::error::ErrorMetadata {
         566  +
        match self {
         567  +
            Self::InternalServerError(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         568  +
            Self::OpsMetadataInvalidArgumentException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         569  +
            Self::OpsMetadataNotFoundException(_inner) => ::aws_smithy_types::error::metadata::ProvideErrorMetadata::meta(_inner),
         570  +
            Self::Unhandled(_inner) => &_inner.meta,
         571  +
        }
         572  +
    }
         573  +
}
         574  +
impl ::aws_smithy_runtime_api::client::result::CreateUnhandledError for DeleteOpsMetadataError {
         575  +
    fn create_unhandled_error(
         576  +
        source: ::std::boxed::Box<dyn ::std::error::Error + ::std::marker::Send + ::std::marker::Sync + 'static>,
         577  +
        meta: ::std::option::Option<::aws_smithy_types::error::ErrorMetadata>,
         578  +
    ) -> Self {
         579  +
        Self::Unhandled(crate::error::sealed_unhandled::Unhandled {
         580  +
            source,
         581  +
            meta: meta.unwrap_or_default(),
         582  +
        })
         583  +
    }
         584  +
}
         585  +
impl ::aws_types::request_id::RequestId for crate::operation::delete_ops_metadata::DeleteOpsMetadataError {
         586  +
    fn request_id(&self) -> Option<&str> {
         587  +
        self.meta().request_id()
         588  +
    }
         589  +
}
         590  +
         591  +
pub use crate::operation::delete_ops_metadata::_delete_ops_metadata_input::DeleteOpsMetadataInput;
         592  +
         593  +
pub use crate::operation::delete_ops_metadata::_delete_ops_metadata_output::DeleteOpsMetadataOutput;
         594  +
         595  +
mod _delete_ops_metadata_input;
         596  +
         597  +
mod _delete_ops_metadata_output;
         598  +
         599  +
/// Builders
         600  +
pub mod builders;

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/delete_ops_metadata/_delete_ops_metadata_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 DeleteOpsMetadataInput {
           6  +
    /// <p>The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.</p>
           7  +
    pub ops_metadata_arn: ::std::option::Option<::std::string::String>,
           8  +
}
           9  +
impl DeleteOpsMetadataInput {
          10  +
    /// <p>The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.</p>
          11  +
    pub fn ops_metadata_arn(&self) -> ::std::option::Option<&str> {
          12  +
        self.ops_metadata_arn.as_deref()
          13  +
    }
          14  +
}
          15  +
static DELETEOPSMETADATAINPUT_MEMBER_OPS_METADATA_ARN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          16  +
    ::aws_smithy_schema::ShapeId::from_parts(
          17  +
        "com.amazonaws.ssm.synthetic#DeleteOpsMetadataInput$OpsMetadataArn",
          18  +
        "com.amazonaws.ssm.synthetic",
          19  +
        "DeleteOpsMetadataInput",
          20  +
    ),
          21  +
    ::aws_smithy_schema::ShapeType::String,
          22  +
    "OpsMetadataArn",
          23  +
    0,
          24  +
);
          25  +
static DELETEOPSMETADATAINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          26  +
    ::aws_smithy_schema::ShapeId::from_parts(
          27  +
        "com.amazonaws.ssm.synthetic#DeleteOpsMetadataInput",
          28  +
        "com.amazonaws.ssm.synthetic",
          29  +
        "DeleteOpsMetadataInput",
          30  +
    ),
          31  +
    ::aws_smithy_schema::ShapeType::Structure,
          32  +
    &[&DELETEOPSMETADATAINPUT_MEMBER_OPS_METADATA_ARN],
          33  +
)
          34  +
.with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
          35  +
.with_original_name("DeleteOpsMetadataRequest");
          36  +
impl DeleteOpsMetadataInput {
          37  +
    /// The schema for this shape.
          38  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DELETEOPSMETADATAINPUT_SCHEMA;
          39  +
}
          40  +
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteOpsMetadataInput {
          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.ops_metadata_arn {
          47  +
            ser.write_string(&DELETEOPSMETADATAINPUT_MEMBER_OPS_METADATA_ARN, val)?;
          48  +
        }
          49  +
        Ok(())
          50  +
    }
          51  +
}
          52  +
impl DeleteOpsMetadataInput {
          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(&DELETEOPSMETADATAINPUT_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.ops_metadata_arn = Some(deser.read_string(member)?);
          73  +
                    }
          74  +
                }
          75  +
                _ => {}
          76  +
            }
          77  +
            Ok(())
          78  +
        })?;
          79  +
        builder.ops_metadata_arn = builder.ops_metadata_arn.or(Some(String::new()));
          80  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
          81  +
    }
          82  +
}
          83  +
impl DeleteOpsMetadataInput {
          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 DeleteOpsMetadataInput {
          95  +
    /// Creates a new builder-style object to manufacture [`DeleteOpsMetadataInput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataInput).
          96  +
    pub fn builder() -> crate::operation::delete_ops_metadata::builders::DeleteOpsMetadataInputBuilder {
          97  +
        crate::operation::delete_ops_metadata::builders::DeleteOpsMetadataInputBuilder::default()
          98  +
    }
          99  +
}
         100  +
         101  +
/// A builder for [`DeleteOpsMetadataInput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataInput).
         102  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         103  +
#[non_exhaustive]
         104  +
pub struct DeleteOpsMetadataInputBuilder {
         105  +
    pub(crate) ops_metadata_arn: ::std::option::Option<::std::string::String>,
         106  +
}
         107  +
impl DeleteOpsMetadataInputBuilder {
         108  +
    /// <p>The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.</p>
         109  +
    /// This field is required.
         110  +
    pub fn ops_metadata_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         111  +
        self.ops_metadata_arn = ::std::option::Option::Some(input.into());
         112  +
        self
         113  +
    }
         114  +
    /// <p>The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.</p>
         115  +
    pub fn set_ops_metadata_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         116  +
        self.ops_metadata_arn = input;
         117  +
        self
         118  +
    }
         119  +
    /// <p>The Amazon Resource Name (ARN) of an OpsMetadata Object to delete.</p>
         120  +
    pub fn get_ops_metadata_arn(&self) -> &::std::option::Option<::std::string::String> {
         121  +
        &self.ops_metadata_arn
         122  +
    }
         123  +
    /// Consumes the builder and constructs a [`DeleteOpsMetadataInput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataInput).
         124  +
    pub fn build(
         125  +
        self,
         126  +
    ) -> ::std::result::Result<crate::operation::delete_ops_metadata::DeleteOpsMetadataInput, ::aws_smithy_types::error::operation::BuildError> {
         127  +
        ::std::result::Result::Ok(crate::operation::delete_ops_metadata::DeleteOpsMetadataInput {
         128  +
            ops_metadata_arn: self.ops_metadata_arn,
         129  +
        })
         130  +
    }
         131  +
}

tmp-codegen-diff/aws-sdk/sdk/ssm/src/operation/delete_ops_metadata/_delete_ops_metadata_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 DeleteOpsMetadataOutput {
           6  +
    _request_id: Option<String>,
           7  +
}
           8  +
static DELETEOPSMETADATAOUTPUT_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 DELETEOPSMETADATAOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          16  +
    ::aws_smithy_schema::ShapeId::from_parts(
          17  +
        "com.amazonaws.ssm.synthetic#DeleteOpsMetadataOutput",
          18  +
        "com.amazonaws.ssm.synthetic",
          19  +
        "DeleteOpsMetadataOutput",
          20  +
    ),
          21  +
    ::aws_smithy_schema::ShapeType::Structure,
          22  +
    &[&DELETEOPSMETADATAOUTPUT_MEMBER__REQUEST_ID],
          23  +
)
          24  +
.with_original_name("DeleteOpsMetadataResult");
          25  +
impl DeleteOpsMetadataOutput {
          26  +
    /// The schema for this shape.
          27  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &DELETEOPSMETADATAOUTPUT_SCHEMA;
          28  +
}
          29  +
impl ::aws_smithy_schema::serde::SerializableStruct for DeleteOpsMetadataOutput {
          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 DeleteOpsMetadataOutput {
          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(&DELETEOPSMETADATAOUTPUT_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 DeleteOpsMetadataOutput {
          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 DeleteOpsMetadataOutput {
          83  +
    fn request_id(&self) -> Option<&str> {
          84  +
        self._request_id.as_deref()
          85  +
    }
          86  +
}
          87  +
impl DeleteOpsMetadataOutput {
          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 DeleteOpsMetadataOutput {
          94  +
    /// Creates a new builder-style object to manufacture [`DeleteOpsMetadataOutput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput).
          95  +
    pub fn builder() -> crate::operation::delete_ops_metadata::builders::DeleteOpsMetadataOutputBuilder {
          96  +
        crate::operation::delete_ops_metadata::builders::DeleteOpsMetadataOutputBuilder::default()
          97  +
    }
          98  +
}
          99  +
         100  +
/// A builder for [`DeleteOpsMetadataOutput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput).
         101  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         102  +
#[non_exhaustive]
         103  +
pub struct DeleteOpsMetadataOutputBuilder {
         104  +
    _request_id: Option<String>,
         105  +
}
         106  +
impl DeleteOpsMetadataOutputBuilder {
         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 [`DeleteOpsMetadataOutput`](crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput).
         117  +
    pub fn build(self) -> crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput {
         118  +
        crate::operation::delete_ops_metadata::DeleteOpsMetadataOutput {
         119  +
            _request_id: self._request_id,
         120  +
        }
         121  +
    }
         122  +
}