AWS SDK

AWS SDK

rev. 97ba95e6039d206ffea5b866ddc214d34f7f88c3

Files changed:

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

@@ -0,1 +0,159 @@
           1  +
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
pub use crate::operation::get_maintenance_window_execution_task_invocation::_get_maintenance_window_execution_task_invocation_input::GetMaintenanceWindowExecutionTaskInvocationInputBuilder;
           3  +
           4  +
pub use crate::operation::get_maintenance_window_execution_task_invocation::_get_maintenance_window_execution_task_invocation_output::GetMaintenanceWindowExecutionTaskInvocationOutputBuilder;
           5  +
           6  +
impl crate::operation::get_maintenance_window_execution_task_invocation::builders::GetMaintenanceWindowExecutionTaskInvocationInputBuilder {
           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::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationOutput,
          13  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          14  +
            crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError,
          15  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          16  +
        >,
          17  +
    > {
          18  +
        let mut fluent_builder = client.get_maintenance_window_execution_task_invocation();
          19  +
        fluent_builder.inner = self;
          20  +
        fluent_builder.send().await
          21  +
    }
          22  +
}
          23  +
/// Fluent builder constructing a request to `GetMaintenanceWindowExecutionTaskInvocation`.
          24  +
///
          25  +
/// <p>Retrieves information about a specific task running on a specific target.</p>
          26  +
#[derive(::std::clone::Clone, ::std::fmt::Debug)]
          27  +
pub struct GetMaintenanceWindowExecutionTaskInvocationFluentBuilder {
          28  +
    handle: ::std::sync::Arc<crate::client::Handle>,
          29  +
    inner: crate::operation::get_maintenance_window_execution_task_invocation::builders::GetMaintenanceWindowExecutionTaskInvocationInputBuilder,
          30  +
    config_override: ::std::option::Option<crate::config::Builder>,
          31  +
}
          32  +
impl
          33  +
    crate::client::customize::internal::CustomizableSend<
          34  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationOutput,
          35  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError,
          36  +
    > for GetMaintenanceWindowExecutionTaskInvocationFluentBuilder
          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::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationOutput,
          44  +
            crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError,
          45  +
        >,
          46  +
    > {
          47  +
        ::std::boxed::Box::pin(async move { self.config_override(config_override).send().await })
          48  +
    }
          49  +
}
          50  +
impl GetMaintenanceWindowExecutionTaskInvocationFluentBuilder {
          51  +
    /// Creates a new `GetMaintenanceWindowExecutionTaskInvocationFluentBuilder`.
          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 GetMaintenanceWindowExecutionTaskInvocation as a reference.
          60  +
    pub fn as_input(
          61  +
        &self,
          62  +
    ) -> &crate::operation::get_maintenance_window_execution_task_invocation::builders::GetMaintenanceWindowExecutionTaskInvocationInputBuilder {
          63  +
        &self.inner
          64  +
    }
          65  +
    /// Sends the request and returns the response.
          66  +
    ///
          67  +
    /// If an error occurs, an `SdkError` will be returned with additional details that
          68  +
    /// can be matched against.
          69  +
    ///
          70  +
    /// By default, any retryable failures will be retried twice. Retry behavior
          71  +
    /// is configurable with the [RetryConfig](aws_smithy_types::retry::RetryConfig), which can be
          72  +
    /// set when configuring the client.
          73  +
    pub async fn send(
          74  +
        self,
          75  +
    ) -> ::std::result::Result<
          76  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationOutput,
          77  +
        ::aws_smithy_runtime_api::client::result::SdkError<
          78  +
            crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError,
          79  +
            ::aws_smithy_runtime_api::client::orchestrator::HttpResponse,
          80  +
        >,
          81  +
    > {
          82  +
        let input = self
          83  +
            .inner
          84  +
            .build()
          85  +
            .map_err(::aws_smithy_runtime_api::client::result::SdkError::construction_failure)?;
          86  +
        let runtime_plugins = crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocation::operation_runtime_plugins(
          87  +
                            self.handle.runtime_plugins.clone(),
          88  +
                            &self.handle.conf,
          89  +
                            self.config_override,
          90  +
                        );
          91  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocation::orchestrate(
          92  +
            &runtime_plugins,
          93  +
            input,
          94  +
        )
          95  +
        .await
          96  +
    }
          97  +
          98  +
    /// Consumes this builder, creating a customizable operation that can be modified before being sent.
          99  +
    pub fn customize(
         100  +
        self,
         101  +
    ) -> crate::client::customize::CustomizableOperation<
         102  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationOutput,
         103  +
        crate::operation::get_maintenance_window_execution_task_invocation::GetMaintenanceWindowExecutionTaskInvocationError,
         104  +
        Self,
         105  +
    > {
         106  +
        crate::client::customize::CustomizableOperation::new(self)
         107  +
    }
         108  +
    pub(crate) fn config_override(mut self, config_override: impl ::std::convert::Into<crate::config::Builder>) -> Self {
         109  +
        self.set_config_override(::std::option::Option::Some(config_override.into()));
         110  +
        self
         111  +
    }
         112  +
         113  +
    pub(crate) fn set_config_override(&mut self, config_override: ::std::option::Option<crate::config::Builder>) -> &mut Self {
         114  +
        self.config_override = config_override;
         115  +
        self
         116  +
    }
         117  +
    /// <p>The ID of the maintenance window execution for which the task is a part.</p>
         118  +
    pub fn window_execution_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         119  +
        self.inner = self.inner.window_execution_id(input.into());
         120  +
        self
         121  +
    }
         122  +
    /// <p>The ID of the maintenance window execution for which the task is a part.</p>
         123  +
    pub fn set_window_execution_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         124  +
        self.inner = self.inner.set_window_execution_id(input);
         125  +
        self
         126  +
    }
         127  +
    /// <p>The ID of the maintenance window execution for which the task is a part.</p>
         128  +
    pub fn get_window_execution_id(&self) -> &::std::option::Option<::std::string::String> {
         129  +
        self.inner.get_window_execution_id()
         130  +
    }
         131  +
    /// <p>The ID of the specific task in the maintenance window task that should be retrieved.</p>
         132  +
    pub fn task_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         133  +
        self.inner = self.inner.task_id(input.into());
         134  +
        self
         135  +
    }
         136  +
    /// <p>The ID of the specific task in the maintenance window task that should be retrieved.</p>
         137  +
    pub fn set_task_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         138  +
        self.inner = self.inner.set_task_id(input);
         139  +
        self
         140  +
    }
         141  +
    /// <p>The ID of the specific task in the maintenance window task that should be retrieved.</p>
         142  +
    pub fn get_task_id(&self) -> &::std::option::Option<::std::string::String> {
         143  +
        self.inner.get_task_id()
         144  +
    }
         145  +
    /// <p>The invocation ID to retrieve.</p>
         146  +
    pub fn invocation_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         147  +
        self.inner = self.inner.invocation_id(input.into());
         148  +
        self
         149  +
    }
         150  +
    /// <p>The invocation ID to retrieve.</p>
         151  +
    pub fn set_invocation_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         152  +
        self.inner = self.inner.set_invocation_id(input);
         153  +
        self
         154  +
    }
         155  +
    /// <p>The invocation ID to retrieve.</p>
         156  +
    pub fn get_invocation_id(&self) -> &::std::option::Option<::std::string::String> {
         157  +
        self.inner.get_invocation_id()
         158  +
    }
         159  +
}

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

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

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

@@ -0,1 +0,181 @@
           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 GetMaintenanceWindowTaskInput {
           6  +
    /// <p>The maintenance window ID that includes the task to retrieve.</p>
           7  +
    pub window_id: ::std::option::Option<::std::string::String>,
           8  +
    /// <p>The maintenance window task ID to retrieve.</p>
           9  +
    pub window_task_id: ::std::option::Option<::std::string::String>,
          10  +
}
          11  +
impl GetMaintenanceWindowTaskInput {
          12  +
    /// <p>The maintenance window ID that includes the task to retrieve.</p>
          13  +
    pub fn window_id(&self) -> ::std::option::Option<&str> {
          14  +
        self.window_id.as_deref()
          15  +
    }
          16  +
    /// <p>The maintenance window task ID to retrieve.</p>
          17  +
    pub fn window_task_id(&self) -> ::std::option::Option<&str> {
          18  +
        self.window_task_id.as_deref()
          19  +
    }
          20  +
}
          21  +
static GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          22  +
    ::aws_smithy_schema::ShapeId::from_parts(
          23  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskInput$WindowId",
          24  +
        "com.amazonaws.ssm.synthetic",
          25  +
        "GetMaintenanceWindowTaskInput",
          26  +
    ),
          27  +
    ::aws_smithy_schema::ShapeType::String,
          28  +
    "WindowId",
          29  +
    0,
          30  +
);
          31  +
static GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_TASK_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
          32  +
    ::aws_smithy_schema::ShapeId::from_parts(
          33  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskInput$WindowTaskId",
          34  +
        "com.amazonaws.ssm.synthetic",
          35  +
        "GetMaintenanceWindowTaskInput",
          36  +
    ),
          37  +
    ::aws_smithy_schema::ShapeType::String,
          38  +
    "WindowTaskId",
          39  +
    1,
          40  +
);
          41  +
static GETMAINTENANCEWINDOWTASKINPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
          42  +
    ::aws_smithy_schema::ShapeId::from_parts(
          43  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskInput",
          44  +
        "com.amazonaws.ssm.synthetic",
          45  +
        "GetMaintenanceWindowTaskInput",
          46  +
    ),
          47  +
    ::aws_smithy_schema::ShapeType::Structure,
          48  +
    &[
          49  +
        &GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_ID,
          50  +
        &GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_TASK_ID,
          51  +
    ],
          52  +
)
          53  +
.with_payload_hint(::aws_smithy_schema::PayloadHint::NoStructPayload)
          54  +
.with_original_name("GetMaintenanceWindowTaskRequest");
          55  +
impl GetMaintenanceWindowTaskInput {
          56  +
    /// The schema for this shape.
          57  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GETMAINTENANCEWINDOWTASKINPUT_SCHEMA;
          58  +
}
          59  +
impl ::aws_smithy_schema::serde::SerializableStruct for GetMaintenanceWindowTaskInput {
          60  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
          61  +
    fn serialize_members(
          62  +
        &self,
          63  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
          64  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
          65  +
        if let Some(ref val) = self.window_id {
          66  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_ID, val)?;
          67  +
        }
          68  +
        if let Some(ref val) = self.window_task_id {
          69  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKINPUT_MEMBER_WINDOW_TASK_ID, val)?;
          70  +
        }
          71  +
        Ok(())
          72  +
    }
          73  +
}
          74  +
impl GetMaintenanceWindowTaskInput {
          75  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
          76  +
    pub fn deserialize(
          77  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
          78  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
          79  +
        #[allow(unused_variables, unused_mut)]
          80  +
        let mut builder = Self::builder();
          81  +
        #[allow(
          82  +
            unused_variables,
          83  +
            unreachable_code,
          84  +
            clippy::single_match,
          85  +
            clippy::match_single_binding,
          86  +
            clippy::diverging_sub_expression
          87  +
        )]
          88  +
        deserializer.read_struct(&GETMAINTENANCEWINDOWTASKINPUT_SCHEMA, &mut |member, deser| {
          89  +
            match member.member_index() {
          90  +
                Some(0) => {
          91  +
                    if deser.is_null() {
          92  +
                        deser.read_null()?;
          93  +
                    } else {
          94  +
                        builder.window_id = Some(deser.read_string(member)?);
          95  +
                    }
          96  +
                }
          97  +
                Some(1) => {
          98  +
                    if deser.is_null() {
          99  +
                        deser.read_null()?;
         100  +
                    } else {
         101  +
                        builder.window_task_id = Some(deser.read_string(member)?);
         102  +
                    }
         103  +
                }
         104  +
                _ => {}
         105  +
            }
         106  +
            Ok(())
         107  +
        })?;
         108  +
        builder.window_id = builder.window_id.or(Some(String::new()));
         109  +
        builder.window_task_id = builder.window_task_id.or(Some(String::new()));
         110  +
        builder.build().map_err(|e| aws_smithy_schema::serde::SerdeError::custom(e.to_string()))
         111  +
    }
         112  +
}
         113  +
impl GetMaintenanceWindowTaskInput {
         114  +
    /// Deserializes this structure from a body deserializer and HTTP response.
         115  +
    pub fn deserialize_with_response(
         116  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         117  +
        _headers: &::aws_smithy_runtime_api::http::Headers,
         118  +
        _status: u16,
         119  +
        _body: &[u8],
         120  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         121  +
        Self::deserialize(deserializer)
         122  +
    }
         123  +
}
         124  +
impl GetMaintenanceWindowTaskInput {
         125  +
    /// Creates a new builder-style object to manufacture [`GetMaintenanceWindowTaskInput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskInput).
         126  +
    pub fn builder() -> crate::operation::get_maintenance_window_task::builders::GetMaintenanceWindowTaskInputBuilder {
         127  +
        crate::operation::get_maintenance_window_task::builders::GetMaintenanceWindowTaskInputBuilder::default()
         128  +
    }
         129  +
}
         130  +
         131  +
/// A builder for [`GetMaintenanceWindowTaskInput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskInput).
         132  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         133  +
#[non_exhaustive]
         134  +
pub struct GetMaintenanceWindowTaskInputBuilder {
         135  +
    pub(crate) window_id: ::std::option::Option<::std::string::String>,
         136  +
    pub(crate) window_task_id: ::std::option::Option<::std::string::String>,
         137  +
}
         138  +
impl GetMaintenanceWindowTaskInputBuilder {
         139  +
    /// <p>The maintenance window ID that includes the task to retrieve.</p>
         140  +
    /// This field is required.
         141  +
    pub fn window_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         142  +
        self.window_id = ::std::option::Option::Some(input.into());
         143  +
        self
         144  +
    }
         145  +
    /// <p>The maintenance window ID that includes the task to retrieve.</p>
         146  +
    pub fn set_window_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         147  +
        self.window_id = input;
         148  +
        self
         149  +
    }
         150  +
    /// <p>The maintenance window ID that includes the task to retrieve.</p>
         151  +
    pub fn get_window_id(&self) -> &::std::option::Option<::std::string::String> {
         152  +
        &self.window_id
         153  +
    }
         154  +
    /// <p>The maintenance window task ID to retrieve.</p>
         155  +
    /// This field is required.
         156  +
    pub fn window_task_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         157  +
        self.window_task_id = ::std::option::Option::Some(input.into());
         158  +
        self
         159  +
    }
         160  +
    /// <p>The maintenance window task ID to retrieve.</p>
         161  +
    pub fn set_window_task_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         162  +
        self.window_task_id = input;
         163  +
        self
         164  +
    }
         165  +
    /// <p>The maintenance window task ID to retrieve.</p>
         166  +
    pub fn get_window_task_id(&self) -> &::std::option::Option<::std::string::String> {
         167  +
        &self.window_task_id
         168  +
    }
         169  +
    /// Consumes the builder and constructs a [`GetMaintenanceWindowTaskInput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskInput).
         170  +
    pub fn build(
         171  +
        self,
         172  +
    ) -> ::std::result::Result<
         173  +
        crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskInput,
         174  +
        ::aws_smithy_types::error::operation::BuildError,
         175  +
    > {
         176  +
        ::std::result::Result::Ok(crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskInput {
         177  +
            window_id: self.window_id,
         178  +
            window_task_id: self.window_task_id,
         179  +
        })
         180  +
    }
         181  +
}

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

@@ -0,1 +0,1072 @@
           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)]
           5  +
pub struct GetMaintenanceWindowTaskOutput {
           6  +
    /// <p>The retrieved maintenance window ID.</p>
           7  +
    pub window_id: ::std::option::Option<::std::string::String>,
           8  +
    /// <p>The retrieved maintenance window task ID.</p>
           9  +
    pub window_task_id: ::std::option::Option<::std::string::String>,
          10  +
    /// <p>The targets where the task should run.</p>
          11  +
    pub targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
          12  +
    /// <p>The resource that the task used during execution. For <code>RUN_COMMAND</code> and <code>AUTOMATION</code> task types, the value of <code>TaskArn</code> is the SSM document name/ARN. For <code>LAMBDA</code> tasks, the value is the function name/ARN. For <code>STEP_FUNCTIONS</code> tasks, the value is the state machine ARN.</p>
          13  +
    pub task_arn: ::std::option::Option<::std::string::String>,
          14  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
          15  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          16  +
    pub service_role_arn: ::std::option::Option<::std::string::String>,
          17  +
    /// <p>The type of task to run.</p>
          18  +
    pub task_type: ::std::option::Option<crate::types::MaintenanceWindowTaskType>,
          19  +
    /// <p>The parameters to pass to the task when it runs.</p><note>
          20  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
          21  +
    /// </note>
          22  +
    pub task_parameters:
          23  +
        ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>>,
          24  +
    /// <p>The parameters to pass to the task when it runs.</p>
          25  +
    pub task_invocation_parameters: ::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters>,
          26  +
    /// <p>The priority of the task when it runs. The lower the number, the higher the priority. Tasks that have the same priority are scheduled in parallel.</p>
          27  +
    pub priority: i32,
          28  +
    /// <p>The maximum number of targets allowed to run this task in parallel.</p><note>
          29  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
          30  +
    /// </note>
          31  +
    pub max_concurrency: ::std::option::Option<::std::string::String>,
          32  +
    /// <p>The maximum number of errors allowed before the task stops being scheduled.</p><note>
          33  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
          34  +
    /// </note>
          35  +
    pub max_errors: ::std::option::Option<::std::string::String>,
          36  +
    /// <p>The location in Amazon Simple Storage Service (Amazon S3) where the task results are logged.</p><note>
          37  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
          38  +
    /// </note>
          39  +
    pub logging_info: ::std::option::Option<crate::types::LoggingInfo>,
          40  +
    /// <p>The retrieved task name.</p>
          41  +
    pub name: ::std::option::Option<::std::string::String>,
          42  +
    /// <p>The retrieved task description.</p>
          43  +
    pub description: ::std::option::Option<::std::string::String>,
          44  +
    /// <p>The action to take on tasks when the maintenance window cutoff time is reached. <code>CONTINUE_TASK</code> means that tasks continue to run. For Automation, Lambda, Step Functions tasks, <code>CANCEL_TASK</code> means that currently running task invocations continue, but no new task invocations are started. For Run Command tasks, <code>CANCEL_TASK</code> means the system attempts to stop the task by sending a <code>CancelCommand</code> operation.</p>
          45  +
    pub cutoff_behavior: ::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior>,
          46  +
    /// <p>The details for the CloudWatch alarm you applied to your maintenance window task.</p>
          47  +
    pub alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
          48  +
    _request_id: Option<String>,
          49  +
}
          50  +
impl GetMaintenanceWindowTaskOutput {
          51  +
    /// <p>The retrieved maintenance window ID.</p>
          52  +
    pub fn window_id(&self) -> ::std::option::Option<&str> {
          53  +
        self.window_id.as_deref()
          54  +
    }
          55  +
    /// <p>The retrieved maintenance window task ID.</p>
          56  +
    pub fn window_task_id(&self) -> ::std::option::Option<&str> {
          57  +
        self.window_task_id.as_deref()
          58  +
    }
          59  +
    /// <p>The targets where the task should run.</p>
          60  +
    ///
          61  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.targets.is_none()`.
          62  +
    pub fn targets(&self) -> &[crate::types::Target] {
          63  +
        self.targets.as_deref().unwrap_or_default()
          64  +
    }
          65  +
    /// <p>The resource that the task used during execution. For <code>RUN_COMMAND</code> and <code>AUTOMATION</code> task types, the value of <code>TaskArn</code> is the SSM document name/ARN. For <code>LAMBDA</code> tasks, the value is the function name/ARN. For <code>STEP_FUNCTIONS</code> tasks, the value is the state machine ARN.</p>
          66  +
    pub fn task_arn(&self) -> ::std::option::Option<&str> {
          67  +
        self.task_arn.as_deref()
          68  +
    }
          69  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
          70  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
          71  +
    pub fn service_role_arn(&self) -> ::std::option::Option<&str> {
          72  +
        self.service_role_arn.as_deref()
          73  +
    }
          74  +
    /// <p>The type of task to run.</p>
          75  +
    pub fn task_type(&self) -> ::std::option::Option<&crate::types::MaintenanceWindowTaskType> {
          76  +
        self.task_type.as_ref()
          77  +
    }
          78  +
    /// <p>The parameters to pass to the task when it runs.</p><note>
          79  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
          80  +
    /// </note>
          81  +
    pub fn task_parameters(
          82  +
        &self,
          83  +
    ) -> ::std::option::Option<&::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>> {
          84  +
        self.task_parameters.as_ref()
          85  +
    }
          86  +
    /// <p>The parameters to pass to the task when it runs.</p>
          87  +
    pub fn task_invocation_parameters(&self) -> ::std::option::Option<&crate::types::MaintenanceWindowTaskInvocationParameters> {
          88  +
        self.task_invocation_parameters.as_ref()
          89  +
    }
          90  +
    /// <p>The priority of the task when it runs. The lower the number, the higher the priority. Tasks that have the same priority are scheduled in parallel.</p>
          91  +
    pub fn priority(&self) -> i32 {
          92  +
        self.priority
          93  +
    }
          94  +
    /// <p>The maximum number of targets allowed to run this task in parallel.</p><note>
          95  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
          96  +
    /// </note>
          97  +
    pub fn max_concurrency(&self) -> ::std::option::Option<&str> {
          98  +
        self.max_concurrency.as_deref()
          99  +
    }
         100  +
    /// <p>The maximum number of errors allowed before the task stops being scheduled.</p><note>
         101  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         102  +
    /// </note>
         103  +
    pub fn max_errors(&self) -> ::std::option::Option<&str> {
         104  +
        self.max_errors.as_deref()
         105  +
    }
         106  +
    /// <p>The location in Amazon Simple Storage Service (Amazon S3) where the task results are logged.</p><note>
         107  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         108  +
    /// </note>
         109  +
    pub fn logging_info(&self) -> ::std::option::Option<&crate::types::LoggingInfo> {
         110  +
        self.logging_info.as_ref()
         111  +
    }
         112  +
    /// <p>The retrieved task name.</p>
         113  +
    pub fn name(&self) -> ::std::option::Option<&str> {
         114  +
        self.name.as_deref()
         115  +
    }
         116  +
    /// <p>The retrieved task description.</p>
         117  +
    pub fn description(&self) -> ::std::option::Option<&str> {
         118  +
        self.description.as_deref()
         119  +
    }
         120  +
    /// <p>The action to take on tasks when the maintenance window cutoff time is reached. <code>CONTINUE_TASK</code> means that tasks continue to run. For Automation, Lambda, Step Functions tasks, <code>CANCEL_TASK</code> means that currently running task invocations continue, but no new task invocations are started. For Run Command tasks, <code>CANCEL_TASK</code> means the system attempts to stop the task by sending a <code>CancelCommand</code> operation.</p>
         121  +
    pub fn cutoff_behavior(&self) -> ::std::option::Option<&crate::types::MaintenanceWindowTaskCutoffBehavior> {
         122  +
        self.cutoff_behavior.as_ref()
         123  +
    }
         124  +
    /// <p>The details for the CloudWatch alarm you applied to your maintenance window task.</p>
         125  +
    pub fn alarm_configuration(&self) -> ::std::option::Option<&crate::types::AlarmConfiguration> {
         126  +
        self.alarm_configuration.as_ref()
         127  +
    }
         128  +
}
         129  +
impl ::std::fmt::Debug for GetMaintenanceWindowTaskOutput {
         130  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
         131  +
        let mut formatter = f.debug_struct("GetMaintenanceWindowTaskOutput");
         132  +
        formatter.field("window_id", &self.window_id);
         133  +
        formatter.field("window_task_id", &self.window_task_id);
         134  +
        formatter.field("targets", &self.targets);
         135  +
        formatter.field("task_arn", &self.task_arn);
         136  +
        formatter.field("service_role_arn", &self.service_role_arn);
         137  +
        formatter.field("task_type", &self.task_type);
         138  +
        formatter.field("task_parameters", &"*** Sensitive Data Redacted ***");
         139  +
        formatter.field("task_invocation_parameters", &self.task_invocation_parameters);
         140  +
        formatter.field("priority", &self.priority);
         141  +
        formatter.field("max_concurrency", &self.max_concurrency);
         142  +
        formatter.field("max_errors", &self.max_errors);
         143  +
        formatter.field("logging_info", &self.logging_info);
         144  +
        formatter.field("name", &self.name);
         145  +
        formatter.field("description", &"*** Sensitive Data Redacted ***");
         146  +
        formatter.field("cutoff_behavior", &self.cutoff_behavior);
         147  +
        formatter.field("alarm_configuration", &self.alarm_configuration);
         148  +
        formatter.field("_request_id", &self._request_id);
         149  +
        formatter.finish()
         150  +
    }
         151  +
}
         152  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         153  +
    ::aws_smithy_schema::ShapeId::from_parts(
         154  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$WindowId",
         155  +
        "com.amazonaws.ssm.synthetic",
         156  +
        "GetMaintenanceWindowTaskOutput",
         157  +
    ),
         158  +
    ::aws_smithy_schema::ShapeType::String,
         159  +
    "WindowId",
         160  +
    0,
         161  +
);
         162  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_TASK_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         163  +
    ::aws_smithy_schema::ShapeId::from_parts(
         164  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$WindowTaskId",
         165  +
        "com.amazonaws.ssm.synthetic",
         166  +
        "GetMaintenanceWindowTaskOutput",
         167  +
    ),
         168  +
    ::aws_smithy_schema::ShapeType::String,
         169  +
    "WindowTaskId",
         170  +
    1,
         171  +
);
         172  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TARGETS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         173  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#Targets$member", "com.amazonaws.ssm", "Targets"),
         174  +
    ::aws_smithy_schema::ShapeType::Structure,
         175  +
    "member",
         176  +
    0,
         177  +
);
         178  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TARGETS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         179  +
    ::aws_smithy_schema::ShapeId::from_parts(
         180  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$Targets",
         181  +
        "com.amazonaws.ssm.synthetic",
         182  +
        "GetMaintenanceWindowTaskOutput",
         183  +
    ),
         184  +
    ::aws_smithy_schema::ShapeType::List,
         185  +
    "Targets",
         186  +
    2,
         187  +
)
         188  +
.with_list_member(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TARGETS_MEMBER);
         189  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_ARN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         190  +
    ::aws_smithy_schema::ShapeId::from_parts(
         191  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$TaskArn",
         192  +
        "com.amazonaws.ssm.synthetic",
         193  +
        "GetMaintenanceWindowTaskOutput",
         194  +
    ),
         195  +
    ::aws_smithy_schema::ShapeType::String,
         196  +
    "TaskArn",
         197  +
    3,
         198  +
);
         199  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_SERVICE_ROLE_ARN: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         200  +
    ::aws_smithy_schema::ShapeId::from_parts(
         201  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$ServiceRoleArn",
         202  +
        "com.amazonaws.ssm.synthetic",
         203  +
        "GetMaintenanceWindowTaskOutput",
         204  +
    ),
         205  +
    ::aws_smithy_schema::ShapeType::String,
         206  +
    "ServiceRoleArn",
         207  +
    4,
         208  +
);
         209  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_TYPE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         210  +
    ::aws_smithy_schema::ShapeId::from_parts(
         211  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$TaskType",
         212  +
        "com.amazonaws.ssm.synthetic",
         213  +
        "GetMaintenanceWindowTaskOutput",
         214  +
    ),
         215  +
    ::aws_smithy_schema::ShapeType::String,
         216  +
    "TaskType",
         217  +
    5,
         218  +
);
         219  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS_KEY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         220  +
    ::aws_smithy_schema::ShapeId::from_parts(
         221  +
        "com.amazonaws.ssm#MaintenanceWindowTaskParameters$key",
         222  +
        "com.amazonaws.ssm",
         223  +
        "MaintenanceWindowTaskParameters",
         224  +
    ),
         225  +
    ::aws_smithy_schema::ShapeType::String,
         226  +
    "key",
         227  +
    0,
         228  +
);
         229  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS_VALUE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         230  +
    ::aws_smithy_schema::ShapeId::from_parts(
         231  +
        "com.amazonaws.ssm#MaintenanceWindowTaskParameters$value",
         232  +
        "com.amazonaws.ssm",
         233  +
        "MaintenanceWindowTaskParameters",
         234  +
    ),
         235  +
    ::aws_smithy_schema::ShapeType::Structure,
         236  +
    "value",
         237  +
    1,
         238  +
);
         239  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         240  +
    ::aws_smithy_schema::ShapeId::from_parts(
         241  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$TaskParameters",
         242  +
        "com.amazonaws.ssm.synthetic",
         243  +
        "GetMaintenanceWindowTaskOutput",
         244  +
    ),
         245  +
    ::aws_smithy_schema::ShapeType::Map,
         246  +
    "TaskParameters",
         247  +
    6,
         248  +
)
         249  +
.with_map_members(
         250  +
    &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS_KEY,
         251  +
    &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS_VALUE,
         252  +
);
         253  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_INVOCATION_PARAMETERS: ::aws_smithy_schema::Schema<'static> =
         254  +
    ::aws_smithy_schema::Schema::new_member(
         255  +
        ::aws_smithy_schema::ShapeId::from_parts(
         256  +
            "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$TaskInvocationParameters",
         257  +
            "com.amazonaws.ssm.synthetic",
         258  +
            "GetMaintenanceWindowTaskOutput",
         259  +
        ),
         260  +
        ::aws_smithy_schema::ShapeType::Structure,
         261  +
        "TaskInvocationParameters",
         262  +
        7,
         263  +
    );
         264  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_PRIORITY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         265  +
    ::aws_smithy_schema::ShapeId::from_parts(
         266  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$Priority",
         267  +
        "com.amazonaws.ssm.synthetic",
         268  +
        "GetMaintenanceWindowTaskOutput",
         269  +
    ),
         270  +
    ::aws_smithy_schema::ShapeType::Integer,
         271  +
    "Priority",
         272  +
    8,
         273  +
);
         274  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_CONCURRENCY: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         275  +
    ::aws_smithy_schema::ShapeId::from_parts(
         276  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$MaxConcurrency",
         277  +
        "com.amazonaws.ssm.synthetic",
         278  +
        "GetMaintenanceWindowTaskOutput",
         279  +
    ),
         280  +
    ::aws_smithy_schema::ShapeType::String,
         281  +
    "MaxConcurrency",
         282  +
    9,
         283  +
);
         284  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_ERRORS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         285  +
    ::aws_smithy_schema::ShapeId::from_parts(
         286  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$MaxErrors",
         287  +
        "com.amazonaws.ssm.synthetic",
         288  +
        "GetMaintenanceWindowTaskOutput",
         289  +
    ),
         290  +
    ::aws_smithy_schema::ShapeType::String,
         291  +
    "MaxErrors",
         292  +
    10,
         293  +
);
         294  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_LOGGING_INFO: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         295  +
    ::aws_smithy_schema::ShapeId::from_parts(
         296  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$LoggingInfo",
         297  +
        "com.amazonaws.ssm.synthetic",
         298  +
        "GetMaintenanceWindowTaskOutput",
         299  +
    ),
         300  +
    ::aws_smithy_schema::ShapeType::Structure,
         301  +
    "LoggingInfo",
         302  +
    11,
         303  +
);
         304  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         305  +
    ::aws_smithy_schema::ShapeId::from_parts(
         306  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$Name",
         307  +
        "com.amazonaws.ssm.synthetic",
         308  +
        "GetMaintenanceWindowTaskOutput",
         309  +
    ),
         310  +
    ::aws_smithy_schema::ShapeType::String,
         311  +
    "Name",
         312  +
    12,
         313  +
);
         314  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         315  +
    ::aws_smithy_schema::ShapeId::from_parts(
         316  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$Description",
         317  +
        "com.amazonaws.ssm.synthetic",
         318  +
        "GetMaintenanceWindowTaskOutput",
         319  +
    ),
         320  +
    ::aws_smithy_schema::ShapeType::String,
         321  +
    "Description",
         322  +
    13,
         323  +
);
         324  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_CUTOFF_BEHAVIOR: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         325  +
    ::aws_smithy_schema::ShapeId::from_parts(
         326  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$CutoffBehavior",
         327  +
        "com.amazonaws.ssm.synthetic",
         328  +
        "GetMaintenanceWindowTaskOutput",
         329  +
    ),
         330  +
    ::aws_smithy_schema::ShapeType::String,
         331  +
    "CutoffBehavior",
         332  +
    14,
         333  +
);
         334  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_ALARM_CONFIGURATION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         335  +
    ::aws_smithy_schema::ShapeId::from_parts(
         336  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput$AlarmConfiguration",
         337  +
        "com.amazonaws.ssm.synthetic",
         338  +
        "GetMaintenanceWindowTaskOutput",
         339  +
    ),
         340  +
    ::aws_smithy_schema::ShapeType::Structure,
         341  +
    "AlarmConfiguration",
         342  +
    15,
         343  +
);
         344  +
static GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         345  +
    ::aws_smithy_schema::ShapeId::from_parts("synthetic#request_id", "synthetic", "request_id"),
         346  +
    ::aws_smithy_schema::ShapeType::String,
         347  +
    "request_id",
         348  +
    16,
         349  +
)
         350  +
.with_http_header("x-amzn-requestid");
         351  +
static GETMAINTENANCEWINDOWTASKOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         352  +
    ::aws_smithy_schema::ShapeId::from_parts(
         353  +
        "com.amazonaws.ssm.synthetic#GetMaintenanceWindowTaskOutput",
         354  +
        "com.amazonaws.ssm.synthetic",
         355  +
        "GetMaintenanceWindowTaskOutput",
         356  +
    ),
         357  +
    ::aws_smithy_schema::ShapeType::Structure,
         358  +
    &[
         359  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_ID,
         360  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_TASK_ID,
         361  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TARGETS,
         362  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_ARN,
         363  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_SERVICE_ROLE_ARN,
         364  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_TYPE,
         365  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS,
         366  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_INVOCATION_PARAMETERS,
         367  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_PRIORITY,
         368  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_CONCURRENCY,
         369  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_ERRORS,
         370  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_LOGGING_INFO,
         371  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_NAME,
         372  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_DESCRIPTION,
         373  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_CUTOFF_BEHAVIOR,
         374  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_ALARM_CONFIGURATION,
         375  +
        &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER__REQUEST_ID,
         376  +
    ],
         377  +
)
         378  +
.with_original_name("GetMaintenanceWindowTaskResult");
         379  +
impl GetMaintenanceWindowTaskOutput {
         380  +
    /// The schema for this shape.
         381  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GETMAINTENANCEWINDOWTASKOUTPUT_SCHEMA;
         382  +
}
         383  +
impl ::aws_smithy_schema::serde::SerializableStruct for GetMaintenanceWindowTaskOutput {
         384  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         385  +
    fn serialize_members(
         386  +
        &self,
         387  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         388  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         389  +
        if let Some(ref val) = self.window_id {
         390  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_ID, val)?;
         391  +
        }
         392  +
        if let Some(ref val) = self.window_task_id {
         393  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_WINDOW_TASK_ID, val)?;
         394  +
        }
         395  +
        if let Some(ref val) = self.targets {
         396  +
            ser.write_list(
         397  +
                &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TARGETS,
         398  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         399  +
                    for item in val {
         400  +
                        ser.write_struct(crate::types::Target::SCHEMA, item)?;
         401  +
                    }
         402  +
                    Ok(())
         403  +
                },
         404  +
            )?;
         405  +
        }
         406  +
        if let Some(ref val) = self.task_arn {
         407  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_ARN, val)?;
         408  +
        }
         409  +
        if let Some(ref val) = self.service_role_arn {
         410  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_SERVICE_ROLE_ARN, val)?;
         411  +
        }
         412  +
        if let Some(ref val) = self.task_type {
         413  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_TYPE, val.as_str())?;
         414  +
        }
         415  +
        if let Some(ref val) = self.task_parameters {
         416  +
            ser.write_map(
         417  +
                &GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_PARAMETERS,
         418  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         419  +
                    for (key, value) in val {
         420  +
                        ser.write_string(&::aws_smithy_schema::prelude::STRING, key)?;
         421  +
                        ser.write_struct(crate::types::MaintenanceWindowTaskParameterValueExpression::SCHEMA, value)?;
         422  +
                    }
         423  +
                    Ok(())
         424  +
                },
         425  +
            )?;
         426  +
        }
         427  +
        if let Some(ref val) = self.task_invocation_parameters {
         428  +
            ser.write_struct(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_TASK_INVOCATION_PARAMETERS, val)?;
         429  +
        }
         430  +
        {
         431  +
            let val = &self.priority;
         432  +
            ser.write_integer(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_PRIORITY, *val)?;
         433  +
        }
         434  +
        if let Some(ref val) = self.max_concurrency {
         435  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_CONCURRENCY, val)?;
         436  +
        }
         437  +
        if let Some(ref val) = self.max_errors {
         438  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_MAX_ERRORS, val)?;
         439  +
        }
         440  +
        if let Some(ref val) = self.logging_info {
         441  +
            ser.write_struct(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_LOGGING_INFO, val)?;
         442  +
        }
         443  +
        if let Some(ref val) = self.name {
         444  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_NAME, val)?;
         445  +
        }
         446  +
        if let Some(ref val) = self.description {
         447  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_DESCRIPTION, val)?;
         448  +
        }
         449  +
        if let Some(ref val) = self.cutoff_behavior {
         450  +
            ser.write_string(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_CUTOFF_BEHAVIOR, val.as_str())?;
         451  +
        }
         452  +
        if let Some(ref val) = self.alarm_configuration {
         453  +
            ser.write_struct(&GETMAINTENANCEWINDOWTASKOUTPUT_MEMBER_ALARM_CONFIGURATION, val)?;
         454  +
        }
         455  +
        Ok(())
         456  +
    }
         457  +
}
         458  +
impl GetMaintenanceWindowTaskOutput {
         459  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         460  +
    pub fn deserialize(
         461  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         462  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         463  +
        #[allow(unused_variables, unused_mut)]
         464  +
        let mut builder = Self::builder();
         465  +
        #[allow(
         466  +
            unused_variables,
         467  +
            unreachable_code,
         468  +
            clippy::single_match,
         469  +
            clippy::match_single_binding,
         470  +
            clippy::diverging_sub_expression
         471  +
        )]
         472  +
        deserializer.read_struct(&GETMAINTENANCEWINDOWTASKOUTPUT_SCHEMA, &mut |member, deser| {
         473  +
            match member.member_index() {
         474  +
                Some(0) => {
         475  +
                    if deser.is_null() {
         476  +
                        deser.read_null()?;
         477  +
                    } else {
         478  +
                        builder.window_id = Some(deser.read_string(member)?);
         479  +
                    }
         480  +
                }
         481  +
                Some(1) => {
         482  +
                    if deser.is_null() {
         483  +
                        deser.read_null()?;
         484  +
                    } else {
         485  +
                        builder.window_task_id = Some(deser.read_string(member)?);
         486  +
                    }
         487  +
                }
         488  +
                Some(2) => {
         489  +
                    if deser.is_null() {
         490  +
                        deser.read_null()?;
         491  +
                    } else {
         492  +
                        builder.targets = Some({
         493  +
                            let mut container = Vec::new();
         494  +
                            deser.read_list(member, &mut |deser| {
         495  +
                                container.push(crate::types::Target::deserialize(deser)?);
         496  +
                                Ok(())
         497  +
                            })?;
         498  +
                            container
         499  +
                        });
         500  +
                    }
         501  +
                }
         502  +
                Some(3) => {
         503  +
                    if deser.is_null() {
         504  +
                        deser.read_null()?;
         505  +
                    } else {
         506  +
                        builder.task_arn = Some(deser.read_string(member)?);
         507  +
                    }
         508  +
                }
         509  +
                Some(4) => {
         510  +
                    if deser.is_null() {
         511  +
                        deser.read_null()?;
         512  +
                    } else {
         513  +
                        builder.service_role_arn = Some(deser.read_string(member)?);
         514  +
                    }
         515  +
                }
         516  +
                Some(5) => {
         517  +
                    if deser.is_null() {
         518  +
                        deser.read_null()?;
         519  +
                    } else {
         520  +
                        builder.task_type = Some(crate::types::MaintenanceWindowTaskType::from(deser.read_string(member)?.as_str()));
         521  +
                    }
         522  +
                }
         523  +
                Some(6) => {
         524  +
                    if deser.is_null() {
         525  +
                        deser.read_null()?;
         526  +
                    } else {
         527  +
                        builder.task_parameters = Some({
         528  +
                            let mut container = std::collections::HashMap::new();
         529  +
                            deser.read_map(member, &mut |key, deser| {
         530  +
                                container.insert(key, crate::types::MaintenanceWindowTaskParameterValueExpression::deserialize(deser)?);
         531  +
                                Ok(())
         532  +
                            })?;
         533  +
                            container
         534  +
                        });
         535  +
                    }
         536  +
                }
         537  +
                Some(7) => {
         538  +
                    if deser.is_null() {
         539  +
                        deser.read_null()?;
         540  +
                    } else {
         541  +
                        builder.task_invocation_parameters = Some(crate::types::MaintenanceWindowTaskInvocationParameters::deserialize(deser)?);
         542  +
                    }
         543  +
                }
         544  +
                Some(8) => {
         545  +
                    builder.priority = Some(deser.read_integer(member)?);
         546  +
                }
         547  +
                Some(9) => {
         548  +
                    if deser.is_null() {
         549  +
                        deser.read_null()?;
         550  +
                    } else {
         551  +
                        builder.max_concurrency = Some(deser.read_string(member)?);
         552  +
                    }
         553  +
                }
         554  +
                Some(10) => {
         555  +
                    if deser.is_null() {
         556  +
                        deser.read_null()?;
         557  +
                    } else {
         558  +
                        builder.max_errors = Some(deser.read_string(member)?);
         559  +
                    }
         560  +
                }
         561  +
                Some(11) => {
         562  +
                    if deser.is_null() {
         563  +
                        deser.read_null()?;
         564  +
                    } else {
         565  +
                        builder.logging_info = Some(crate::types::LoggingInfo::deserialize(deser)?);
         566  +
                    }
         567  +
                }
         568  +
                Some(12) => {
         569  +
                    if deser.is_null() {
         570  +
                        deser.read_null()?;
         571  +
                    } else {
         572  +
                        builder.name = Some(deser.read_string(member)?);
         573  +
                    }
         574  +
                }
         575  +
                Some(13) => {
         576  +
                    if deser.is_null() {
         577  +
                        deser.read_null()?;
         578  +
                    } else {
         579  +
                        builder.description = Some(deser.read_string(member)?);
         580  +
                    }
         581  +
                }
         582  +
                Some(14) => {
         583  +
                    if deser.is_null() {
         584  +
                        deser.read_null()?;
         585  +
                    } else {
         586  +
                        builder.cutoff_behavior = Some(crate::types::MaintenanceWindowTaskCutoffBehavior::from(
         587  +
                            deser.read_string(member)?.as_str(),
         588  +
                        ));
         589  +
                    }
         590  +
                }
         591  +
                Some(15) => {
         592  +
                    if deser.is_null() {
         593  +
                        deser.read_null()?;
         594  +
                    } else {
         595  +
                        builder.alarm_configuration = Some(crate::types::AlarmConfiguration::deserialize(deser)?);
         596  +
                    }
         597  +
                }
         598  +
                Some(16) => {
         599  +
                    builder._request_id = Some(deser.read_string(member)?);
         600  +
                }
         601  +
                _ => {}
         602  +
            }
         603  +
            Ok(())
         604  +
        })?;
         605  +
        Ok(builder.build())
         606  +
    }
         607  +
}
         608  +
impl GetMaintenanceWindowTaskOutput {
         609  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         610  +
    /// Header-bound members are read directly from headers, avoiding runtime
         611  +
    /// member iteration overhead. Body members are read via the deserializer.
         612  +
    pub fn deserialize_with_response(
         613  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         614  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         615  +
        _status: u16,
         616  +
        _body: &[u8],
         617  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         618  +
        #[allow(unused_variables, unused_mut)]
         619  +
        let mut builder = Self::builder();
         620  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         621  +
            builder._request_id = Some(val.to_string());
         622  +
        }
         623  +
         624  +
        #[allow(
         625  +
            unused_variables,
         626  +
            unreachable_code,
         627  +
            clippy::single_match,
         628  +
            clippy::match_single_binding,
         629  +
            clippy::diverging_sub_expression
         630  +
        )]
         631  +
        deserializer.read_struct(&GETMAINTENANCEWINDOWTASKOUTPUT_SCHEMA, &mut |member, deser| {
         632  +
            match member.member_index() {
         633  +
                Some(0) => {
         634  +
                    builder.window_id = Some(deser.read_string(member)?);
         635  +
                }
         636  +
                Some(1) => {
         637  +
                    builder.window_task_id = Some(deser.read_string(member)?);
         638  +
                }
         639  +
                Some(2) => {
         640  +
                    builder.targets = Some({
         641  +
                        let mut container = Vec::new();
         642  +
                        deser.read_list(member, &mut |deser| {
         643  +
                            container.push(crate::types::Target::deserialize(deser)?);
         644  +
                            Ok(())
         645  +
                        })?;
         646  +
                        container
         647  +
                    });
         648  +
                }
         649  +
                Some(3) => {
         650  +
                    builder.task_arn = Some(deser.read_string(member)?);
         651  +
                }
         652  +
                Some(4) => {
         653  +
                    builder.service_role_arn = Some(deser.read_string(member)?);
         654  +
                }
         655  +
                Some(5) => {
         656  +
                    builder.task_type = Some(crate::types::MaintenanceWindowTaskType::from(deser.read_string(member)?.as_str()));
         657  +
                }
         658  +
                Some(6) => {
         659  +
                    builder.task_parameters = Some({
         660  +
                        let mut container = std::collections::HashMap::new();
         661  +
                        deser.read_map(member, &mut |key, deser| {
         662  +
                            container.insert(key, crate::types::MaintenanceWindowTaskParameterValueExpression::deserialize(deser)?);
         663  +
                            Ok(())
         664  +
                        })?;
         665  +
                        container
         666  +
                    });
         667  +
                }
         668  +
                Some(7) => {
         669  +
                    builder.task_invocation_parameters = Some(crate::types::MaintenanceWindowTaskInvocationParameters::deserialize(deser)?);
         670  +
                }
         671  +
                Some(8) => {
         672  +
                    builder.priority = Some(deser.read_integer(member)?);
         673  +
                }
         674  +
                Some(9) => {
         675  +
                    builder.max_concurrency = Some(deser.read_string(member)?);
         676  +
                }
         677  +
                Some(10) => {
         678  +
                    builder.max_errors = Some(deser.read_string(member)?);
         679  +
                }
         680  +
                Some(11) => {
         681  +
                    builder.logging_info = Some(crate::types::LoggingInfo::deserialize(deser)?);
         682  +
                }
         683  +
                Some(12) => {
         684  +
                    builder.name = Some(deser.read_string(member)?);
         685  +
                }
         686  +
                Some(13) => {
         687  +
                    builder.description = Some(deser.read_string(member)?);
         688  +
                }
         689  +
                Some(14) => {
         690  +
                    builder.cutoff_behavior = Some(crate::types::MaintenanceWindowTaskCutoffBehavior::from(
         691  +
                        deser.read_string(member)?.as_str(),
         692  +
                    ));
         693  +
                }
         694  +
                Some(15) => {
         695  +
                    builder.alarm_configuration = Some(crate::types::AlarmConfiguration::deserialize(deser)?);
         696  +
                }
         697  +
                _ => {}
         698  +
            }
         699  +
            Ok(())
         700  +
        })?;
         701  +
        Ok(builder.build())
         702  +
    }
         703  +
}
         704  +
impl ::aws_types::request_id::RequestId for GetMaintenanceWindowTaskOutput {
         705  +
    fn request_id(&self) -> Option<&str> {
         706  +
        self._request_id.as_deref()
         707  +
    }
         708  +
}
         709  +
impl GetMaintenanceWindowTaskOutput {
         710  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         711  +
        self._request_id = request_id;
         712  +
        self
         713  +
    }
         714  +
}
         715  +
impl GetMaintenanceWindowTaskOutput {
         716  +
    /// Creates a new builder-style object to manufacture [`GetMaintenanceWindowTaskOutput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskOutput).
         717  +
    pub fn builder() -> crate::operation::get_maintenance_window_task::builders::GetMaintenanceWindowTaskOutputBuilder {
         718  +
        crate::operation::get_maintenance_window_task::builders::GetMaintenanceWindowTaskOutputBuilder::default()
         719  +
    }
         720  +
}
         721  +
         722  +
/// A builder for [`GetMaintenanceWindowTaskOutput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskOutput).
         723  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default)]
         724  +
#[non_exhaustive]
         725  +
pub struct GetMaintenanceWindowTaskOutputBuilder {
         726  +
    pub(crate) window_id: ::std::option::Option<::std::string::String>,
         727  +
    pub(crate) window_task_id: ::std::option::Option<::std::string::String>,
         728  +
    pub(crate) targets: ::std::option::Option<::std::vec::Vec<crate::types::Target>>,
         729  +
    pub(crate) task_arn: ::std::option::Option<::std::string::String>,
         730  +
    pub(crate) service_role_arn: ::std::option::Option<::std::string::String>,
         731  +
    pub(crate) task_type: ::std::option::Option<crate::types::MaintenanceWindowTaskType>,
         732  +
    pub(crate) task_parameters:
         733  +
        ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>>,
         734  +
    pub(crate) task_invocation_parameters: ::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters>,
         735  +
    pub(crate) priority: ::std::option::Option<i32>,
         736  +
    pub(crate) max_concurrency: ::std::option::Option<::std::string::String>,
         737  +
    pub(crate) max_errors: ::std::option::Option<::std::string::String>,
         738  +
    pub(crate) logging_info: ::std::option::Option<crate::types::LoggingInfo>,
         739  +
    pub(crate) name: ::std::option::Option<::std::string::String>,
         740  +
    pub(crate) description: ::std::option::Option<::std::string::String>,
         741  +
    pub(crate) cutoff_behavior: ::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior>,
         742  +
    pub(crate) alarm_configuration: ::std::option::Option<crate::types::AlarmConfiguration>,
         743  +
    _request_id: Option<String>,
         744  +
}
         745  +
impl GetMaintenanceWindowTaskOutputBuilder {
         746  +
    /// <p>The retrieved maintenance window ID.</p>
         747  +
    pub fn window_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         748  +
        self.window_id = ::std::option::Option::Some(input.into());
         749  +
        self
         750  +
    }
         751  +
    /// <p>The retrieved maintenance window ID.</p>
         752  +
    pub fn set_window_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         753  +
        self.window_id = input;
         754  +
        self
         755  +
    }
         756  +
    /// <p>The retrieved maintenance window ID.</p>
         757  +
    pub fn get_window_id(&self) -> &::std::option::Option<::std::string::String> {
         758  +
        &self.window_id
         759  +
    }
         760  +
    /// <p>The retrieved maintenance window task ID.</p>
         761  +
    pub fn window_task_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         762  +
        self.window_task_id = ::std::option::Option::Some(input.into());
         763  +
        self
         764  +
    }
         765  +
    /// <p>The retrieved maintenance window task ID.</p>
         766  +
    pub fn set_window_task_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         767  +
        self.window_task_id = input;
         768  +
        self
         769  +
    }
         770  +
    /// <p>The retrieved maintenance window task ID.</p>
         771  +
    pub fn get_window_task_id(&self) -> &::std::option::Option<::std::string::String> {
         772  +
        &self.window_task_id
         773  +
    }
         774  +
    /// Appends an item to `targets`.
         775  +
    ///
         776  +
    /// To override the contents of this collection use [`set_targets`](Self::set_targets).
         777  +
    ///
         778  +
    /// <p>The targets where the task should run.</p>
         779  +
    pub fn targets(mut self, input: crate::types::Target) -> Self {
         780  +
        let mut v = self.targets.unwrap_or_default();
         781  +
        v.push(input);
         782  +
        self.targets = ::std::option::Option::Some(v);
         783  +
        self
         784  +
    }
         785  +
    /// <p>The targets where the task should run.</p>
         786  +
    pub fn set_targets(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::Target>>) -> Self {
         787  +
        self.targets = input;
         788  +
        self
         789  +
    }
         790  +
    /// <p>The targets where the task should run.</p>
         791  +
    pub fn get_targets(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::Target>> {
         792  +
        &self.targets
         793  +
    }
         794  +
    /// <p>The resource that the task used during execution. For <code>RUN_COMMAND</code> and <code>AUTOMATION</code> task types, the value of <code>TaskArn</code> is the SSM document name/ARN. For <code>LAMBDA</code> tasks, the value is the function name/ARN. For <code>STEP_FUNCTIONS</code> tasks, the value is the state machine ARN.</p>
         795  +
    pub fn task_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         796  +
        self.task_arn = ::std::option::Option::Some(input.into());
         797  +
        self
         798  +
    }
         799  +
    /// <p>The resource that the task used during execution. For <code>RUN_COMMAND</code> and <code>AUTOMATION</code> task types, the value of <code>TaskArn</code> is the SSM document name/ARN. For <code>LAMBDA</code> tasks, the value is the function name/ARN. For <code>STEP_FUNCTIONS</code> tasks, the value is the state machine ARN.</p>
         800  +
    pub fn set_task_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         801  +
        self.task_arn = input;
         802  +
        self
         803  +
    }
         804  +
    /// <p>The resource that the task used during execution. For <code>RUN_COMMAND</code> and <code>AUTOMATION</code> task types, the value of <code>TaskArn</code> is the SSM document name/ARN. For <code>LAMBDA</code> tasks, the value is the function name/ARN. For <code>STEP_FUNCTIONS</code> tasks, the value is the state machine ARN.</p>
         805  +
    pub fn get_task_arn(&self) -> &::std::option::Option<::std::string::String> {
         806  +
        &self.task_arn
         807  +
    }
         808  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         809  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         810  +
    pub fn service_role_arn(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         811  +
        self.service_role_arn = ::std::option::Option::Some(input.into());
         812  +
        self
         813  +
    }
         814  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         815  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         816  +
    pub fn set_service_role_arn(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         817  +
        self.service_role_arn = input;
         818  +
        self
         819  +
    }
         820  +
    /// <p>The Amazon Resource Name (ARN) of the IAM service role for Amazon Web Services Systems Manager to assume when running a maintenance window task. If you do not specify a service role ARN, Systems Manager uses a service-linked role in your account. If no appropriate service-linked role for Systems Manager exists in your account, it is created when you run <code>RegisterTaskWithMaintenanceWindow</code>.</p>
         821  +
    /// <p>However, for an improved security posture, we strongly recommend creating a custom policy and custom service role for running your maintenance window tasks. The policy can be crafted to provide only the permissions needed for your particular maintenance window tasks. For more information, see <a href="https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-maintenance-permissions.html">Setting up Maintenance Windows</a> in the in the <i>Amazon Web Services Systems Manager User Guide</i>.</p>
         822  +
    pub fn get_service_role_arn(&self) -> &::std::option::Option<::std::string::String> {
         823  +
        &self.service_role_arn
         824  +
    }
         825  +
    /// <p>The type of task to run.</p>
         826  +
    pub fn task_type(mut self, input: crate::types::MaintenanceWindowTaskType) -> Self {
         827  +
        self.task_type = ::std::option::Option::Some(input);
         828  +
        self
         829  +
    }
         830  +
    /// <p>The type of task to run.</p>
         831  +
    pub fn set_task_type(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskType>) -> Self {
         832  +
        self.task_type = input;
         833  +
        self
         834  +
    }
         835  +
    /// <p>The type of task to run.</p>
         836  +
    pub fn get_task_type(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskType> {
         837  +
        &self.task_type
         838  +
    }
         839  +
    /// Adds a key-value pair to `task_parameters`.
         840  +
    ///
         841  +
    /// To override the contents of this collection use [`set_task_parameters`](Self::set_task_parameters).
         842  +
    ///
         843  +
    /// <p>The parameters to pass to the task when it runs.</p><note>
         844  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         845  +
    /// </note>
         846  +
    pub fn task_parameters(
         847  +
        mut self,
         848  +
        k: impl ::std::convert::Into<::std::string::String>,
         849  +
        v: crate::types::MaintenanceWindowTaskParameterValueExpression,
         850  +
    ) -> Self {
         851  +
        let mut hash_map = self.task_parameters.unwrap_or_default();
         852  +
        hash_map.insert(k.into(), v);
         853  +
        self.task_parameters = ::std::option::Option::Some(hash_map);
         854  +
        self
         855  +
    }
         856  +
    /// <p>The parameters to pass to the task when it runs.</p><note>
         857  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         858  +
    /// </note>
         859  +
    pub fn set_task_parameters(
         860  +
        mut self,
         861  +
        input: ::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>>,
         862  +
    ) -> Self {
         863  +
        self.task_parameters = input;
         864  +
        self
         865  +
    }
         866  +
    /// <p>The parameters to pass to the task when it runs.</p><note>
         867  +
    /// <p><code>TaskParameters</code> has been deprecated. To specify parameters to pass to a task when it runs, instead use the <code>Parameters</code> option in the <code>TaskInvocationParameters</code> structure. For information about how Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         868  +
    /// </note>
         869  +
    pub fn get_task_parameters(
         870  +
        &self,
         871  +
    ) -> &::std::option::Option<::std::collections::HashMap<::std::string::String, crate::types::MaintenanceWindowTaskParameterValueExpression>> {
         872  +
        &self.task_parameters
         873  +
    }
         874  +
    /// <p>The parameters to pass to the task when it runs.</p>
         875  +
    pub fn task_invocation_parameters(mut self, input: crate::types::MaintenanceWindowTaskInvocationParameters) -> Self {
         876  +
        self.task_invocation_parameters = ::std::option::Option::Some(input);
         877  +
        self
         878  +
    }
         879  +
    /// <p>The parameters to pass to the task when it runs.</p>
         880  +
    pub fn set_task_invocation_parameters(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters>) -> Self {
         881  +
        self.task_invocation_parameters = input;
         882  +
        self
         883  +
    }
         884  +
    /// <p>The parameters to pass to the task when it runs.</p>
         885  +
    pub fn get_task_invocation_parameters(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskInvocationParameters> {
         886  +
        &self.task_invocation_parameters
         887  +
    }
         888  +
    /// <p>The priority of the task when it runs. The lower the number, the higher the priority. Tasks that have the same priority are scheduled in parallel.</p>
         889  +
    pub fn priority(mut self, input: i32) -> Self {
         890  +
        self.priority = ::std::option::Option::Some(input);
         891  +
        self
         892  +
    }
         893  +
    /// <p>The priority of the task when it runs. The lower the number, the higher the priority. Tasks that have the same priority are scheduled in parallel.</p>
         894  +
    pub fn set_priority(mut self, input: ::std::option::Option<i32>) -> Self {
         895  +
        self.priority = input;
         896  +
        self
         897  +
    }
         898  +
    /// <p>The priority of the task when it runs. The lower the number, the higher the priority. Tasks that have the same priority are scheduled in parallel.</p>
         899  +
    pub fn get_priority(&self) -> &::std::option::Option<i32> {
         900  +
        &self.priority
         901  +
    }
         902  +
    /// <p>The maximum number of targets allowed to run this task in parallel.</p><note>
         903  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         904  +
    /// </note>
         905  +
    pub fn max_concurrency(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         906  +
        self.max_concurrency = ::std::option::Option::Some(input.into());
         907  +
        self
         908  +
    }
         909  +
    /// <p>The maximum number of targets allowed to run this task in parallel.</p><note>
         910  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         911  +
    /// </note>
         912  +
    pub fn set_max_concurrency(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         913  +
        self.max_concurrency = input;
         914  +
        self
         915  +
    }
         916  +
    /// <p>The maximum number of targets allowed to run this task in parallel.</p><note>
         917  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         918  +
    /// </note>
         919  +
    pub fn get_max_concurrency(&self) -> &::std::option::Option<::std::string::String> {
         920  +
        &self.max_concurrency
         921  +
    }
         922  +
    /// <p>The maximum number of errors allowed before the task stops being scheduled.</p><note>
         923  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         924  +
    /// </note>
         925  +
    pub fn max_errors(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         926  +
        self.max_errors = ::std::option::Option::Some(input.into());
         927  +
        self
         928  +
    }
         929  +
    /// <p>The maximum number of errors allowed before the task stops being scheduled.</p><note>
         930  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         931  +
    /// </note>
         932  +
    pub fn set_max_errors(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         933  +
        self.max_errors = input;
         934  +
        self
         935  +
    }
         936  +
    /// <p>The maximum number of errors allowed before the task stops being scheduled.</p><note>
         937  +
    /// <p>For maintenance window tasks without a target specified, you can't supply a value for this option. Instead, the system inserts a placeholder value of <code>1</code>, which may be reported in the response to this command. This value doesn't affect the running of your task and can be ignored.</p>
         938  +
    /// </note>
         939  +
    pub fn get_max_errors(&self) -> &::std::option::Option<::std::string::String> {
         940  +
        &self.max_errors
         941  +
    }
         942  +
    /// <p>The location in Amazon Simple Storage Service (Amazon S3) where the task results are logged.</p><note>
         943  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         944  +
    /// </note>
         945  +
    pub fn logging_info(mut self, input: crate::types::LoggingInfo) -> Self {
         946  +
        self.logging_info = ::std::option::Option::Some(input);
         947  +
        self
         948  +
    }
         949  +
    /// <p>The location in Amazon Simple Storage Service (Amazon S3) where the task results are logged.</p><note>
         950  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         951  +
    /// </note>
         952  +
    pub fn set_logging_info(mut self, input: ::std::option::Option<crate::types::LoggingInfo>) -> Self {
         953  +
        self.logging_info = input;
         954  +
        self
         955  +
    }
         956  +
    /// <p>The location in Amazon Simple Storage Service (Amazon S3) where the task results are logged.</p><note>
         957  +
    /// <p><code>LoggingInfo</code> has been deprecated. To specify an Amazon Simple Storage Service (Amazon S3) bucket to contain logs, instead use the <code>OutputS3BucketName</code> and <code>OutputS3KeyPrefix</code> options in the <code>TaskInvocationParameters</code> structure. For information about how Amazon Web Services Systems Manager handles these options for the supported maintenance window task types, see <code>MaintenanceWindowTaskInvocationParameters</code>.</p>
         958  +
    /// </note>
         959  +
    pub fn get_logging_info(&self) -> &::std::option::Option<crate::types::LoggingInfo> {
         960  +
        &self.logging_info
         961  +
    }
         962  +
    /// <p>The retrieved task name.</p>
         963  +
    pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         964  +
        self.name = ::std::option::Option::Some(input.into());
         965  +
        self
         966  +
    }
         967  +
    /// <p>The retrieved task name.</p>
         968  +
    pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         969  +
        self.name = input;
         970  +
        self
         971  +
    }
         972  +
    /// <p>The retrieved task name.</p>
         973  +
    pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         974  +
        &self.name
         975  +
    }
         976  +
    /// <p>The retrieved task description.</p>
         977  +
    pub fn description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         978  +
        self.description = ::std::option::Option::Some(input.into());
         979  +
        self
         980  +
    }
         981  +
    /// <p>The retrieved task description.</p>
         982  +
    pub fn set_description(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         983  +
        self.description = input;
         984  +
        self
         985  +
    }
         986  +
    /// <p>The retrieved task description.</p>
         987  +
    pub fn get_description(&self) -> &::std::option::Option<::std::string::String> {
         988  +
        &self.description
         989  +
    }
         990  +
    /// <p>The action to take on tasks when the maintenance window cutoff time is reached. <code>CONTINUE_TASK</code> means that tasks continue to run. For Automation, Lambda, Step Functions tasks, <code>CANCEL_TASK</code> means that currently running task invocations continue, but no new task invocations are started. For Run Command tasks, <code>CANCEL_TASK</code> means the system attempts to stop the task by sending a <code>CancelCommand</code> operation.</p>
         991  +
    pub fn cutoff_behavior(mut self, input: crate::types::MaintenanceWindowTaskCutoffBehavior) -> Self {
         992  +
        self.cutoff_behavior = ::std::option::Option::Some(input);
         993  +
        self
         994  +
    }
         995  +
    /// <p>The action to take on tasks when the maintenance window cutoff time is reached. <code>CONTINUE_TASK</code> means that tasks continue to run. For Automation, Lambda, Step Functions tasks, <code>CANCEL_TASK</code> means that currently running task invocations continue, but no new task invocations are started. For Run Command tasks, <code>CANCEL_TASK</code> means the system attempts to stop the task by sending a <code>CancelCommand</code> operation.</p>
         996  +
    pub fn set_cutoff_behavior(mut self, input: ::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior>) -> Self {
         997  +
        self.cutoff_behavior = input;
         998  +
        self
         999  +
    }
        1000  +
    /// <p>The action to take on tasks when the maintenance window cutoff time is reached. <code>CONTINUE_TASK</code> means that tasks continue to run. For Automation, Lambda, Step Functions tasks, <code>CANCEL_TASK</code> means that currently running task invocations continue, but no new task invocations are started. For Run Command tasks, <code>CANCEL_TASK</code> means the system attempts to stop the task by sending a <code>CancelCommand</code> operation.</p>
        1001  +
    pub fn get_cutoff_behavior(&self) -> &::std::option::Option<crate::types::MaintenanceWindowTaskCutoffBehavior> {
        1002  +
        &self.cutoff_behavior
        1003  +
    }
        1004  +
    /// <p>The details for the CloudWatch alarm you applied to your maintenance window task.</p>
        1005  +
    pub fn alarm_configuration(mut self, input: crate::types::AlarmConfiguration) -> Self {
        1006  +
        self.alarm_configuration = ::std::option::Option::Some(input);
        1007  +
        self
        1008  +
    }
        1009  +
    /// <p>The details for the CloudWatch alarm you applied to your maintenance window task.</p>
        1010  +
    pub fn set_alarm_configuration(mut self, input: ::std::option::Option<crate::types::AlarmConfiguration>) -> Self {
        1011  +
        self.alarm_configuration = input;
        1012  +
        self
        1013  +
    }
        1014  +
    /// <p>The details for the CloudWatch alarm you applied to your maintenance window task.</p>
        1015  +
    pub fn get_alarm_configuration(&self) -> &::std::option::Option<crate::types::AlarmConfiguration> {
        1016  +
        &self.alarm_configuration
        1017  +
    }
        1018  +
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
        1019  +
        self._request_id = Some(request_id.into());
        1020  +
        self
        1021  +
    }
        1022  +
        1023  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
        1024  +
        self._request_id = request_id;
        1025  +
        self
        1026  +
    }
        1027  +
    /// Consumes the builder and constructs a [`GetMaintenanceWindowTaskOutput`](crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskOutput).
        1028  +
    pub fn build(self) -> crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskOutput {
        1029  +
        crate::operation::get_maintenance_window_task::GetMaintenanceWindowTaskOutput {
        1030  +
            window_id: self.window_id,
        1031  +
            window_task_id: self.window_task_id,
        1032  +
            targets: self.targets,
        1033  +
            task_arn: self.task_arn,
        1034  +
            service_role_arn: self.service_role_arn,
        1035  +
            task_type: self.task_type,
        1036  +
            task_parameters: self.task_parameters,
        1037  +
            task_invocation_parameters: self.task_invocation_parameters,
        1038  +
            priority: self.priority.unwrap_or_default(),
        1039  +
            max_concurrency: self.max_concurrency,
        1040  +
            max_errors: self.max_errors,
        1041  +
            logging_info: self.logging_info,
        1042  +
            name: self.name,
        1043  +
            description: self.description,
        1044  +
            cutoff_behavior: self.cutoff_behavior,
        1045  +
            alarm_configuration: self.alarm_configuration,
        1046  +
            _request_id: self._request_id,
        1047  +
        }
        1048  +
    }
        1049  +
}
        1050  +
impl ::std::fmt::Debug for GetMaintenanceWindowTaskOutputBuilder {
        1051  +
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        1052  +
        let mut formatter = f.debug_struct("GetMaintenanceWindowTaskOutputBuilder");
        1053  +
        formatter.field("window_id", &self.window_id);
        1054  +
        formatter.field("window_task_id", &self.window_task_id);
        1055  +
        formatter.field("targets", &self.targets);
        1056  +
        formatter.field("task_arn", &self.task_arn);
        1057  +
        formatter.field("service_role_arn", &self.service_role_arn);
        1058  +
        formatter.field("task_type", &self.task_type);
        1059  +
        formatter.field("task_parameters", &"*** Sensitive Data Redacted ***");
        1060  +
        formatter.field("task_invocation_parameters", &self.task_invocation_parameters);
        1061  +
        formatter.field("priority", &self.priority);
        1062  +
        formatter.field("max_concurrency", &self.max_concurrency);
        1063  +
        formatter.field("max_errors", &self.max_errors);
        1064  +
        formatter.field("logging_info", &self.logging_info);
        1065  +
        formatter.field("name", &self.name);
        1066  +
        formatter.field("description", &"*** Sensitive Data Redacted ***");
        1067  +
        formatter.field("cutoff_behavior", &self.cutoff_behavior);
        1068  +
        formatter.field("alarm_configuration", &self.alarm_configuration);
        1069  +
        formatter.field("_request_id", &self._request_id);
        1070  +
        formatter.finish()
        1071  +
    }
        1072  +
}