AWS SDK

AWS SDK

rev. 18b1dd205ff4335251e6dd0ecb88193de1b1cede (ignoring whitespace)

Files changed:

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

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

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

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

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

@@ -0,1 +0,993 @@
           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 GetPatchBaselineOutput {
           6  +
    /// <p>The ID of the retrieved patch baseline.</p>
           7  +
    pub baseline_id: ::std::option::Option<::std::string::String>,
           8  +
    /// <p>The name of the patch baseline.</p>
           9  +
    pub name: ::std::option::Option<::std::string::String>,
          10  +
    /// <p>Returns the operating system specified for the patch baseline.</p>
          11  +
    pub operating_system: ::std::option::Option<crate::types::OperatingSystem>,
          12  +
    /// <p>A set of global filters used to exclude patches from the baseline.</p>
          13  +
    pub global_filters: ::std::option::Option<crate::types::PatchFilterGroup>,
          14  +
    /// <p>A set of rules used to include patches in the baseline.</p>
          15  +
    pub approval_rules: ::std::option::Option<crate::types::PatchRuleGroup>,
          16  +
    /// <p>A list of explicitly approved patches for the baseline.</p>
          17  +
    pub approved_patches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          18  +
    /// <p>Returns the specified compliance severity level for approved patches in the patch baseline.</p>
          19  +
    pub approved_patches_compliance_level: ::std::option::Option<crate::types::PatchComplianceLevel>,
          20  +
    /// <p>Indicates whether the list of approved patches includes non-security updates that should be applied to the managed nodes. The default value is <code>false</code>. Applies to Linux managed nodes only.</p>
          21  +
    pub approved_patches_enable_non_security: ::std::option::Option<bool>,
          22  +
    /// <p>A list of explicitly rejected patches for the baseline.</p>
          23  +
    pub rejected_patches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          24  +
    /// <p>The action specified to take on patches included in the <code>RejectedPatches</code> list. A patch can be allowed only if it is a dependency of another package, or blocked entirely along with packages that include it as a dependency.</p>
          25  +
    pub rejected_patches_action: ::std::option::Option<crate::types::PatchAction>,
          26  +
    /// <p>Patch groups included in the patch baseline.</p>
          27  +
    pub patch_groups: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
          28  +
    /// <p>The date the patch baseline was created.</p>
          29  +
    pub created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
          30  +
    /// <p>The date the patch baseline was last modified.</p>
          31  +
    pub modified_date: ::std::option::Option<::aws_smithy_types::DateTime>,
          32  +
    /// <p>A description of the patch baseline.</p>
          33  +
    pub description: ::std::option::Option<::std::string::String>,
          34  +
    /// <p>Information about the patches to use to update the managed nodes, including target operating systems and source repositories. Applies to Linux managed nodes only.</p>
          35  +
    pub sources: ::std::option::Option<::std::vec::Vec<crate::types::PatchSource>>,
          36  +
    /// <p>Indicates the compliance status of managed nodes for which security-related patches are available but were not approved. This preference is specified when the <code>CreatePatchBaseline</code> or <code>UpdatePatchBaseline</code> commands are run.</p>
          37  +
    /// <p>Applies to Windows Server managed nodes only.</p>
          38  +
    pub available_security_updates_compliance_status: ::std::option::Option<crate::types::PatchComplianceStatus>,
          39  +
    _request_id: Option<String>,
          40  +
}
          41  +
impl GetPatchBaselineOutput {
          42  +
    /// <p>The ID of the retrieved patch baseline.</p>
          43  +
    pub fn baseline_id(&self) -> ::std::option::Option<&str> {
          44  +
        self.baseline_id.as_deref()
          45  +
    }
          46  +
    /// <p>The name of the patch baseline.</p>
          47  +
    pub fn name(&self) -> ::std::option::Option<&str> {
          48  +
        self.name.as_deref()
          49  +
    }
          50  +
    /// <p>Returns the operating system specified for the patch baseline.</p>
          51  +
    pub fn operating_system(&self) -> ::std::option::Option<&crate::types::OperatingSystem> {
          52  +
        self.operating_system.as_ref()
          53  +
    }
          54  +
    /// <p>A set of global filters used to exclude patches from the baseline.</p>
          55  +
    pub fn global_filters(&self) -> ::std::option::Option<&crate::types::PatchFilterGroup> {
          56  +
        self.global_filters.as_ref()
          57  +
    }
          58  +
    /// <p>A set of rules used to include patches in the baseline.</p>
          59  +
    pub fn approval_rules(&self) -> ::std::option::Option<&crate::types::PatchRuleGroup> {
          60  +
        self.approval_rules.as_ref()
          61  +
    }
          62  +
    /// <p>A list of explicitly approved patches for the baseline.</p>
          63  +
    ///
          64  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.approved_patches.is_none()`.
          65  +
    pub fn approved_patches(&self) -> &[::std::string::String] {
          66  +
        self.approved_patches.as_deref().unwrap_or_default()
          67  +
    }
          68  +
    /// <p>Returns the specified compliance severity level for approved patches in the patch baseline.</p>
          69  +
    pub fn approved_patches_compliance_level(&self) -> ::std::option::Option<&crate::types::PatchComplianceLevel> {
          70  +
        self.approved_patches_compliance_level.as_ref()
          71  +
    }
          72  +
    /// <p>Indicates whether the list of approved patches includes non-security updates that should be applied to the managed nodes. The default value is <code>false</code>. Applies to Linux managed nodes only.</p>
          73  +
    pub fn approved_patches_enable_non_security(&self) -> ::std::option::Option<bool> {
          74  +
        self.approved_patches_enable_non_security
          75  +
    }
          76  +
    /// <p>A list of explicitly rejected patches for the baseline.</p>
          77  +
    ///
          78  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.rejected_patches.is_none()`.
          79  +
    pub fn rejected_patches(&self) -> &[::std::string::String] {
          80  +
        self.rejected_patches.as_deref().unwrap_or_default()
          81  +
    }
          82  +
    /// <p>The action specified to take on patches included in the <code>RejectedPatches</code> list. A patch can be allowed only if it is a dependency of another package, or blocked entirely along with packages that include it as a dependency.</p>
          83  +
    pub fn rejected_patches_action(&self) -> ::std::option::Option<&crate::types::PatchAction> {
          84  +
        self.rejected_patches_action.as_ref()
          85  +
    }
          86  +
    /// <p>Patch groups included in the patch baseline.</p>
          87  +
    ///
          88  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.patch_groups.is_none()`.
          89  +
    pub fn patch_groups(&self) -> &[::std::string::String] {
          90  +
        self.patch_groups.as_deref().unwrap_or_default()
          91  +
    }
          92  +
    /// <p>The date the patch baseline was created.</p>
          93  +
    pub fn created_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          94  +
        self.created_date.as_ref()
          95  +
    }
          96  +
    /// <p>The date the patch baseline was last modified.</p>
          97  +
    pub fn modified_date(&self) -> ::std::option::Option<&::aws_smithy_types::DateTime> {
          98  +
        self.modified_date.as_ref()
          99  +
    }
         100  +
    /// <p>A description of the patch baseline.</p>
         101  +
    pub fn description(&self) -> ::std::option::Option<&str> {
         102  +
        self.description.as_deref()
         103  +
    }
         104  +
    /// <p>Information about the patches to use to update the managed nodes, including target operating systems and source repositories. Applies to Linux managed nodes only.</p>
         105  +
    ///
         106  +
    /// If no value was sent for this field, a default will be set. If you want to determine if no value was sent, use `.sources.is_none()`.
         107  +
    pub fn sources(&self) -> &[crate::types::PatchSource] {
         108  +
        self.sources.as_deref().unwrap_or_default()
         109  +
    }
         110  +
    /// <p>Indicates the compliance status of managed nodes for which security-related patches are available but were not approved. This preference is specified when the <code>CreatePatchBaseline</code> or <code>UpdatePatchBaseline</code> commands are run.</p>
         111  +
    /// <p>Applies to Windows Server managed nodes only.</p>
         112  +
    pub fn available_security_updates_compliance_status(&self) -> ::std::option::Option<&crate::types::PatchComplianceStatus> {
         113  +
        self.available_security_updates_compliance_status.as_ref()
         114  +
    }
         115  +
}
         116  +
static GETPATCHBASELINEOUTPUT_MEMBER_BASELINE_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         117  +
    ::aws_smithy_schema::ShapeId::from_parts(
         118  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$BaselineId",
         119  +
        "com.amazonaws.ssm.synthetic",
         120  +
        "GetPatchBaselineOutput",
         121  +
    ),
         122  +
    ::aws_smithy_schema::ShapeType::String,
         123  +
    "BaselineId",
         124  +
    0,
         125  +
);
         126  +
static GETPATCHBASELINEOUTPUT_MEMBER_NAME: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         127  +
    ::aws_smithy_schema::ShapeId::from_parts(
         128  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$Name",
         129  +
        "com.amazonaws.ssm.synthetic",
         130  +
        "GetPatchBaselineOutput",
         131  +
    ),
         132  +
    ::aws_smithy_schema::ShapeType::String,
         133  +
    "Name",
         134  +
    1,
         135  +
);
         136  +
static GETPATCHBASELINEOUTPUT_MEMBER_OPERATING_SYSTEM: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         137  +
    ::aws_smithy_schema::ShapeId::from_parts(
         138  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$OperatingSystem",
         139  +
        "com.amazonaws.ssm.synthetic",
         140  +
        "GetPatchBaselineOutput",
         141  +
    ),
         142  +
    ::aws_smithy_schema::ShapeType::String,
         143  +
    "OperatingSystem",
         144  +
    2,
         145  +
);
         146  +
static GETPATCHBASELINEOUTPUT_MEMBER_GLOBAL_FILTERS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         147  +
    ::aws_smithy_schema::ShapeId::from_parts(
         148  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$GlobalFilters",
         149  +
        "com.amazonaws.ssm.synthetic",
         150  +
        "GetPatchBaselineOutput",
         151  +
    ),
         152  +
    ::aws_smithy_schema::ShapeType::Structure,
         153  +
    "GlobalFilters",
         154  +
    3,
         155  +
);
         156  +
static GETPATCHBASELINEOUTPUT_MEMBER_APPROVAL_RULES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         157  +
    ::aws_smithy_schema::ShapeId::from_parts(
         158  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$ApprovalRules",
         159  +
        "com.amazonaws.ssm.synthetic",
         160  +
        "GetPatchBaselineOutput",
         161  +
    ),
         162  +
    ::aws_smithy_schema::ShapeType::Structure,
         163  +
    "ApprovalRules",
         164  +
    4,
         165  +
);
         166  +
static GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         167  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#PatchIdList$member", "com.amazonaws.ssm", "PatchIdList"),
         168  +
    ::aws_smithy_schema::ShapeType::String,
         169  +
    "member",
         170  +
    0,
         171  +
);
         172  +
static GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         173  +
    ::aws_smithy_schema::ShapeId::from_parts(
         174  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$ApprovedPatches",
         175  +
        "com.amazonaws.ssm.synthetic",
         176  +
        "GetPatchBaselineOutput",
         177  +
    ),
         178  +
    ::aws_smithy_schema::ShapeType::List,
         179  +
    "ApprovedPatches",
         180  +
    5,
         181  +
)
         182  +
.with_list_member(&GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_MEMBER);
         183  +
static GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_COMPLIANCE_LEVEL: ::aws_smithy_schema::Schema<'static> =
         184  +
    ::aws_smithy_schema::Schema::new_member(
         185  +
        ::aws_smithy_schema::ShapeId::from_parts(
         186  +
            "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$ApprovedPatchesComplianceLevel",
         187  +
            "com.amazonaws.ssm.synthetic",
         188  +
            "GetPatchBaselineOutput",
         189  +
        ),
         190  +
        ::aws_smithy_schema::ShapeType::String,
         191  +
        "ApprovedPatchesComplianceLevel",
         192  +
        6,
         193  +
    );
         194  +
static GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_ENABLE_NON_SECURITY: ::aws_smithy_schema::Schema<'static> =
         195  +
    ::aws_smithy_schema::Schema::new_member(
         196  +
        ::aws_smithy_schema::ShapeId::from_parts(
         197  +
            "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$ApprovedPatchesEnableNonSecurity",
         198  +
            "com.amazonaws.ssm.synthetic",
         199  +
            "GetPatchBaselineOutput",
         200  +
        ),
         201  +
        ::aws_smithy_schema::ShapeType::Boolean,
         202  +
        "ApprovedPatchesEnableNonSecurity",
         203  +
        7,
         204  +
    );
         205  +
static GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         206  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#PatchIdList$member", "com.amazonaws.ssm", "PatchIdList"),
         207  +
    ::aws_smithy_schema::ShapeType::String,
         208  +
    "member",
         209  +
    0,
         210  +
);
         211  +
static GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         212  +
    ::aws_smithy_schema::ShapeId::from_parts(
         213  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$RejectedPatches",
         214  +
        "com.amazonaws.ssm.synthetic",
         215  +
        "GetPatchBaselineOutput",
         216  +
    ),
         217  +
    ::aws_smithy_schema::ShapeType::List,
         218  +
    "RejectedPatches",
         219  +
    8,
         220  +
)
         221  +
.with_list_member(&GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES_MEMBER);
         222  +
static GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES_ACTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         223  +
    ::aws_smithy_schema::ShapeId::from_parts(
         224  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$RejectedPatchesAction",
         225  +
        "com.amazonaws.ssm.synthetic",
         226  +
        "GetPatchBaselineOutput",
         227  +
    ),
         228  +
    ::aws_smithy_schema::ShapeType::String,
         229  +
    "RejectedPatchesAction",
         230  +
    9,
         231  +
);
         232  +
static GETPATCHBASELINEOUTPUT_MEMBER_PATCH_GROUPS_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         233  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#PatchGroupList$member", "com.amazonaws.ssm", "PatchGroupList"),
         234  +
    ::aws_smithy_schema::ShapeType::String,
         235  +
    "member",
         236  +
    0,
         237  +
);
         238  +
static GETPATCHBASELINEOUTPUT_MEMBER_PATCH_GROUPS: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         239  +
    ::aws_smithy_schema::ShapeId::from_parts(
         240  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$PatchGroups",
         241  +
        "com.amazonaws.ssm.synthetic",
         242  +
        "GetPatchBaselineOutput",
         243  +
    ),
         244  +
    ::aws_smithy_schema::ShapeType::List,
         245  +
    "PatchGroups",
         246  +
    10,
         247  +
)
         248  +
.with_list_member(&GETPATCHBASELINEOUTPUT_MEMBER_PATCH_GROUPS_MEMBER);
         249  +
static GETPATCHBASELINEOUTPUT_MEMBER_CREATED_DATE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         250  +
    ::aws_smithy_schema::ShapeId::from_parts(
         251  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$CreatedDate",
         252  +
        "com.amazonaws.ssm.synthetic",
         253  +
        "GetPatchBaselineOutput",
         254  +
    ),
         255  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         256  +
    "CreatedDate",
         257  +
    11,
         258  +
);
         259  +
static GETPATCHBASELINEOUTPUT_MEMBER_MODIFIED_DATE: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         260  +
    ::aws_smithy_schema::ShapeId::from_parts(
         261  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$ModifiedDate",
         262  +
        "com.amazonaws.ssm.synthetic",
         263  +
        "GetPatchBaselineOutput",
         264  +
    ),
         265  +
    ::aws_smithy_schema::ShapeType::Timestamp,
         266  +
    "ModifiedDate",
         267  +
    12,
         268  +
);
         269  +
static GETPATCHBASELINEOUTPUT_MEMBER_DESCRIPTION: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         270  +
    ::aws_smithy_schema::ShapeId::from_parts(
         271  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$Description",
         272  +
        "com.amazonaws.ssm.synthetic",
         273  +
        "GetPatchBaselineOutput",
         274  +
    ),
         275  +
    ::aws_smithy_schema::ShapeType::String,
         276  +
    "Description",
         277  +
    13,
         278  +
);
         279  +
static GETPATCHBASELINEOUTPUT_MEMBER_SOURCES_MEMBER: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         280  +
    ::aws_smithy_schema::ShapeId::from_parts("com.amazonaws.ssm#PatchSourceList$member", "com.amazonaws.ssm", "PatchSourceList"),
         281  +
    ::aws_smithy_schema::ShapeType::Structure,
         282  +
    "member",
         283  +
    0,
         284  +
);
         285  +
static GETPATCHBASELINEOUTPUT_MEMBER_SOURCES: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         286  +
    ::aws_smithy_schema::ShapeId::from_parts(
         287  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$Sources",
         288  +
        "com.amazonaws.ssm.synthetic",
         289  +
        "GetPatchBaselineOutput",
         290  +
    ),
         291  +
    ::aws_smithy_schema::ShapeType::List,
         292  +
    "Sources",
         293  +
    14,
         294  +
)
         295  +
.with_list_member(&GETPATCHBASELINEOUTPUT_MEMBER_SOURCES_MEMBER);
         296  +
static GETPATCHBASELINEOUTPUT_MEMBER_AVAILABLE_SECURITY_UPDATES_COMPLIANCE_STATUS: ::aws_smithy_schema::Schema<'static> =
         297  +
    ::aws_smithy_schema::Schema::new_member(
         298  +
        ::aws_smithy_schema::ShapeId::from_parts(
         299  +
            "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput$AvailableSecurityUpdatesComplianceStatus",
         300  +
            "com.amazonaws.ssm.synthetic",
         301  +
            "GetPatchBaselineOutput",
         302  +
        ),
         303  +
        ::aws_smithy_schema::ShapeType::String,
         304  +
        "AvailableSecurityUpdatesComplianceStatus",
         305  +
        15,
         306  +
    );
         307  +
static GETPATCHBASELINEOUTPUT_MEMBER__REQUEST_ID: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_member(
         308  +
    ::aws_smithy_schema::ShapeId::from_parts("synthetic#request_id", "synthetic", "request_id"),
         309  +
    ::aws_smithy_schema::ShapeType::String,
         310  +
    "request_id",
         311  +
    16,
         312  +
)
         313  +
.with_http_header("x-amzn-requestid");
         314  +
static GETPATCHBASELINEOUTPUT_SCHEMA: ::aws_smithy_schema::Schema<'static> = ::aws_smithy_schema::Schema::new_struct(
         315  +
    ::aws_smithy_schema::ShapeId::from_parts(
         316  +
        "com.amazonaws.ssm.synthetic#GetPatchBaselineOutput",
         317  +
        "com.amazonaws.ssm.synthetic",
         318  +
        "GetPatchBaselineOutput",
         319  +
    ),
         320  +
    ::aws_smithy_schema::ShapeType::Structure,
         321  +
    &[
         322  +
        &GETPATCHBASELINEOUTPUT_MEMBER_BASELINE_ID,
         323  +
        &GETPATCHBASELINEOUTPUT_MEMBER_NAME,
         324  +
        &GETPATCHBASELINEOUTPUT_MEMBER_OPERATING_SYSTEM,
         325  +
        &GETPATCHBASELINEOUTPUT_MEMBER_GLOBAL_FILTERS,
         326  +
        &GETPATCHBASELINEOUTPUT_MEMBER_APPROVAL_RULES,
         327  +
        &GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES,
         328  +
        &GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_COMPLIANCE_LEVEL,
         329  +
        &GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_ENABLE_NON_SECURITY,
         330  +
        &GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES,
         331  +
        &GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES_ACTION,
         332  +
        &GETPATCHBASELINEOUTPUT_MEMBER_PATCH_GROUPS,
         333  +
        &GETPATCHBASELINEOUTPUT_MEMBER_CREATED_DATE,
         334  +
        &GETPATCHBASELINEOUTPUT_MEMBER_MODIFIED_DATE,
         335  +
        &GETPATCHBASELINEOUTPUT_MEMBER_DESCRIPTION,
         336  +
        &GETPATCHBASELINEOUTPUT_MEMBER_SOURCES,
         337  +
        &GETPATCHBASELINEOUTPUT_MEMBER_AVAILABLE_SECURITY_UPDATES_COMPLIANCE_STATUS,
         338  +
        &GETPATCHBASELINEOUTPUT_MEMBER__REQUEST_ID,
         339  +
    ],
         340  +
)
         341  +
.with_original_name("GetPatchBaselineResult");
         342  +
impl GetPatchBaselineOutput {
         343  +
    /// The schema for this shape.
         344  +
    pub const SCHEMA: &'static ::aws_smithy_schema::Schema<'static> = &GETPATCHBASELINEOUTPUT_SCHEMA;
         345  +
}
         346  +
impl ::aws_smithy_schema::serde::SerializableStruct for GetPatchBaselineOutput {
         347  +
    #[allow(unused_variables, clippy::diverging_sub_expression)]
         348  +
    fn serialize_members(
         349  +
        &self,
         350  +
        ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer,
         351  +
    ) -> ::std::result::Result<(), ::aws_smithy_schema::serde::SerdeError> {
         352  +
        if let Some(ref val) = self.baseline_id {
         353  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_BASELINE_ID, val)?;
         354  +
        }
         355  +
        if let Some(ref val) = self.name {
         356  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_NAME, val)?;
         357  +
        }
         358  +
        if let Some(ref val) = self.operating_system {
         359  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_OPERATING_SYSTEM, val.as_str())?;
         360  +
        }
         361  +
        if let Some(ref val) = self.global_filters {
         362  +
            ser.write_struct(&GETPATCHBASELINEOUTPUT_MEMBER_GLOBAL_FILTERS, val)?;
         363  +
        }
         364  +
        if let Some(ref val) = self.approval_rules {
         365  +
            ser.write_struct(&GETPATCHBASELINEOUTPUT_MEMBER_APPROVAL_RULES, val)?;
         366  +
        }
         367  +
        if let Some(ref val) = self.approved_patches {
         368  +
            ser.write_list(
         369  +
                &GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES,
         370  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         371  +
                    for item in val {
         372  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         373  +
                    }
         374  +
                    Ok(())
         375  +
                },
         376  +
            )?;
         377  +
        }
         378  +
        if let Some(ref val) = self.approved_patches_compliance_level {
         379  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_COMPLIANCE_LEVEL, val.as_str())?;
         380  +
        }
         381  +
        if let Some(ref val) = self.approved_patches_enable_non_security {
         382  +
            ser.write_boolean(&GETPATCHBASELINEOUTPUT_MEMBER_APPROVED_PATCHES_ENABLE_NON_SECURITY, *val)?;
         383  +
        }
         384  +
        if let Some(ref val) = self.rejected_patches {
         385  +
            ser.write_list(
         386  +
                &GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES,
         387  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         388  +
                    for item in val {
         389  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         390  +
                    }
         391  +
                    Ok(())
         392  +
                },
         393  +
            )?;
         394  +
        }
         395  +
        if let Some(ref val) = self.rejected_patches_action {
         396  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_REJECTED_PATCHES_ACTION, val.as_str())?;
         397  +
        }
         398  +
        if let Some(ref val) = self.patch_groups {
         399  +
            ser.write_list(
         400  +
                &GETPATCHBASELINEOUTPUT_MEMBER_PATCH_GROUPS,
         401  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         402  +
                    for item in val {
         403  +
                        ser.write_string(&aws_smithy_schema::prelude::STRING, item)?;
         404  +
                    }
         405  +
                    Ok(())
         406  +
                },
         407  +
            )?;
         408  +
        }
         409  +
        if let Some(ref val) = self.created_date {
         410  +
            ser.write_timestamp(&GETPATCHBASELINEOUTPUT_MEMBER_CREATED_DATE, val)?;
         411  +
        }
         412  +
        if let Some(ref val) = self.modified_date {
         413  +
            ser.write_timestamp(&GETPATCHBASELINEOUTPUT_MEMBER_MODIFIED_DATE, val)?;
         414  +
        }
         415  +
        if let Some(ref val) = self.description {
         416  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_DESCRIPTION, val)?;
         417  +
        }
         418  +
        if let Some(ref val) = self.sources {
         419  +
            ser.write_list(
         420  +
                &GETPATCHBASELINEOUTPUT_MEMBER_SOURCES,
         421  +
                &|ser: &mut dyn ::aws_smithy_schema::serde::ShapeSerializer| {
         422  +
                    for item in val {
         423  +
                        ser.write_struct(crate::types::PatchSource::SCHEMA, item)?;
         424  +
                    }
         425  +
                    Ok(())
         426  +
                },
         427  +
            )?;
         428  +
        }
         429  +
        if let Some(ref val) = self.available_security_updates_compliance_status {
         430  +
            ser.write_string(&GETPATCHBASELINEOUTPUT_MEMBER_AVAILABLE_SECURITY_UPDATES_COMPLIANCE_STATUS, val.as_str())?;
         431  +
        }
         432  +
        Ok(())
         433  +
    }
         434  +
}
         435  +
impl GetPatchBaselineOutput {
         436  +
    /// Deserializes this structure from a [`ShapeDeserializer`].
         437  +
    pub fn deserialize(
         438  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         439  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         440  +
        #[allow(unused_variables, unused_mut)]
         441  +
        let mut builder = Self::builder();
         442  +
        #[allow(
         443  +
            unused_variables,
         444  +
            unreachable_code,
         445  +
            clippy::single_match,
         446  +
            clippy::match_single_binding,
         447  +
            clippy::diverging_sub_expression
         448  +
        )]
         449  +
        deserializer.read_struct(&GETPATCHBASELINEOUTPUT_SCHEMA, &mut |member, deser| {
         450  +
            match member.member_index() {
         451  +
                Some(0) => {
         452  +
                    if deser.is_null() {
         453  +
                        deser.read_null()?;
         454  +
                    } else {
         455  +
                        builder.baseline_id = Some(deser.read_string(member)?);
         456  +
                    }
         457  +
                }
         458  +
                Some(1) => {
         459  +
                    if deser.is_null() {
         460  +
                        deser.read_null()?;
         461  +
                    } else {
         462  +
                        builder.name = Some(deser.read_string(member)?);
         463  +
                    }
         464  +
                }
         465  +
                Some(2) => {
         466  +
                    if deser.is_null() {
         467  +
                        deser.read_null()?;
         468  +
                    } else {
         469  +
                        builder.operating_system = Some(crate::types::OperatingSystem::from(deser.read_string(member)?.as_str()));
         470  +
                    }
         471  +
                }
         472  +
                Some(3) => {
         473  +
                    if deser.is_null() {
         474  +
                        deser.read_null()?;
         475  +
                    } else {
         476  +
                        builder.global_filters = Some(crate::types::PatchFilterGroup::deserialize(deser)?);
         477  +
                    }
         478  +
                }
         479  +
                Some(4) => {
         480  +
                    if deser.is_null() {
         481  +
                        deser.read_null()?;
         482  +
                    } else {
         483  +
                        builder.approval_rules = Some(crate::types::PatchRuleGroup::deserialize(deser)?);
         484  +
                    }
         485  +
                }
         486  +
                Some(5) => {
         487  +
                    if deser.is_null() {
         488  +
                        deser.read_null()?;
         489  +
                    } else {
         490  +
                        builder.approved_patches = Some(deser.read_string_list(member)?);
         491  +
                    }
         492  +
                }
         493  +
                Some(6) => {
         494  +
                    if deser.is_null() {
         495  +
                        deser.read_null()?;
         496  +
                    } else {
         497  +
                        builder.approved_patches_compliance_level =
         498  +
                            Some(crate::types::PatchComplianceLevel::from(deser.read_string(member)?.as_str()));
         499  +
                    }
         500  +
                }
         501  +
                Some(7) => {
         502  +
                    if deser.is_null() {
         503  +
                        deser.read_null()?;
         504  +
                    } else {
         505  +
                        builder.approved_patches_enable_non_security = Some(deser.read_boolean(member)?);
         506  +
                    }
         507  +
                }
         508  +
                Some(8) => {
         509  +
                    if deser.is_null() {
         510  +
                        deser.read_null()?;
         511  +
                    } else {
         512  +
                        builder.rejected_patches = Some(deser.read_string_list(member)?);
         513  +
                    }
         514  +
                }
         515  +
                Some(9) => {
         516  +
                    if deser.is_null() {
         517  +
                        deser.read_null()?;
         518  +
                    } else {
         519  +
                        builder.rejected_patches_action = Some(crate::types::PatchAction::from(deser.read_string(member)?.as_str()));
         520  +
                    }
         521  +
                }
         522  +
                Some(10) => {
         523  +
                    if deser.is_null() {
         524  +
                        deser.read_null()?;
         525  +
                    } else {
         526  +
                        builder.patch_groups = Some(deser.read_string_list(member)?);
         527  +
                    }
         528  +
                }
         529  +
                Some(11) => {
         530  +
                    if deser.is_null() {
         531  +
                        deser.read_null()?;
         532  +
                    } else {
         533  +
                        builder.created_date = Some(deser.read_timestamp(member)?);
         534  +
                    }
         535  +
                }
         536  +
                Some(12) => {
         537  +
                    if deser.is_null() {
         538  +
                        deser.read_null()?;
         539  +
                    } else {
         540  +
                        builder.modified_date = Some(deser.read_timestamp(member)?);
         541  +
                    }
         542  +
                }
         543  +
                Some(13) => {
         544  +
                    if deser.is_null() {
         545  +
                        deser.read_null()?;
         546  +
                    } else {
         547  +
                        builder.description = Some(deser.read_string(member)?);
         548  +
                    }
         549  +
                }
         550  +
                Some(14) => {
         551  +
                    if deser.is_null() {
         552  +
                        deser.read_null()?;
         553  +
                    } else {
         554  +
                        builder.sources = Some({
         555  +
                            let mut container = Vec::new();
         556  +
                            deser.read_list(member, &mut |deser| {
         557  +
                                container.push(crate::types::PatchSource::deserialize(deser)?);
         558  +
                                Ok(())
         559  +
                            })?;
         560  +
                            container
         561  +
                        });
         562  +
                    }
         563  +
                }
         564  +
                Some(15) => {
         565  +
                    if deser.is_null() {
         566  +
                        deser.read_null()?;
         567  +
                    } else {
         568  +
                        builder.available_security_updates_compliance_status =
         569  +
                            Some(crate::types::PatchComplianceStatus::from(deser.read_string(member)?.as_str()));
         570  +
                    }
         571  +
                }
         572  +
                Some(16) => {
         573  +
                    builder._request_id = Some(deser.read_string(member)?);
         574  +
                }
         575  +
                _ => {}
         576  +
            }
         577  +
            Ok(())
         578  +
        })?;
         579  +
        Ok(builder.build())
         580  +
    }
         581  +
}
         582  +
impl GetPatchBaselineOutput {
         583  +
    /// Deserializes this structure from a body deserializer and HTTP response headers.
         584  +
    /// Header-bound members are read directly from headers, avoiding runtime
         585  +
    /// member iteration overhead. Body members are read via the deserializer.
         586  +
    pub fn deserialize_with_response(
         587  +
        deserializer: &mut dyn ::aws_smithy_schema::serde::ShapeDeserializer,
         588  +
        headers: &::aws_smithy_runtime_api::http::Headers,
         589  +
        _status: u16,
         590  +
        _body: &[u8],
         591  +
    ) -> ::std::result::Result<Self, ::aws_smithy_schema::serde::SerdeError> {
         592  +
        #[allow(unused_variables, unused_mut)]
         593  +
        let mut builder = Self::builder();
         594  +
        if let Some(val) = headers.get("x-amzn-requestid") {
         595  +
            builder._request_id = Some(val.to_string());
         596  +
        }
         597  +
         598  +
        #[allow(
         599  +
            unused_variables,
         600  +
            unreachable_code,
         601  +
            clippy::single_match,
         602  +
            clippy::match_single_binding,
         603  +
            clippy::diverging_sub_expression
         604  +
        )]
         605  +
        deserializer.read_struct(&GETPATCHBASELINEOUTPUT_SCHEMA, &mut |member, deser| {
         606  +
            match member.member_index() {
         607  +
                Some(0) => {
         608  +
                    builder.baseline_id = Some(deser.read_string(member)?);
         609  +
                }
         610  +
                Some(1) => {
         611  +
                    builder.name = Some(deser.read_string(member)?);
         612  +
                }
         613  +
                Some(2) => {
         614  +
                    builder.operating_system = Some(crate::types::OperatingSystem::from(deser.read_string(member)?.as_str()));
         615  +
                }
         616  +
                Some(3) => {
         617  +
                    builder.global_filters = Some(crate::types::PatchFilterGroup::deserialize(deser)?);
         618  +
                }
         619  +
                Some(4) => {
         620  +
                    builder.approval_rules = Some(crate::types::PatchRuleGroup::deserialize(deser)?);
         621  +
                }
         622  +
                Some(5) => {
         623  +
                    builder.approved_patches = Some(deser.read_string_list(member)?);
         624  +
                }
         625  +
                Some(6) => {
         626  +
                    builder.approved_patches_compliance_level = Some(crate::types::PatchComplianceLevel::from(deser.read_string(member)?.as_str()));
         627  +
                }
         628  +
                Some(7) => {
         629  +
                    builder.approved_patches_enable_non_security = Some(deser.read_boolean(member)?);
         630  +
                }
         631  +
                Some(8) => {
         632  +
                    builder.rejected_patches = Some(deser.read_string_list(member)?);
         633  +
                }
         634  +
                Some(9) => {
         635  +
                    builder.rejected_patches_action = Some(crate::types::PatchAction::from(deser.read_string(member)?.as_str()));
         636  +
                }
         637  +
                Some(10) => {
         638  +
                    builder.patch_groups = Some(deser.read_string_list(member)?);
         639  +
                }
         640  +
                Some(11) => {
         641  +
                    builder.created_date = Some(deser.read_timestamp(member)?);
         642  +
                }
         643  +
                Some(12) => {
         644  +
                    builder.modified_date = Some(deser.read_timestamp(member)?);
         645  +
                }
         646  +
                Some(13) => {
         647  +
                    builder.description = Some(deser.read_string(member)?);
         648  +
                }
         649  +
                Some(14) => {
         650  +
                    builder.sources = Some({
         651  +
                        let mut container = Vec::new();
         652  +
                        deser.read_list(member, &mut |deser| {
         653  +
                            container.push(crate::types::PatchSource::deserialize(deser)?);
         654  +
                            Ok(())
         655  +
                        })?;
         656  +
                        container
         657  +
                    });
         658  +
                }
         659  +
                Some(15) => {
         660  +
                    builder.available_security_updates_compliance_status =
         661  +
                        Some(crate::types::PatchComplianceStatus::from(deser.read_string(member)?.as_str()));
         662  +
                }
         663  +
                _ => {}
         664  +
            }
         665  +
            Ok(())
         666  +
        })?;
         667  +
        Ok(builder.build())
         668  +
    }
         669  +
}
         670  +
impl ::aws_types::request_id::RequestId for GetPatchBaselineOutput {
         671  +
    fn request_id(&self) -> Option<&str> {
         672  +
        self._request_id.as_deref()
         673  +
    }
         674  +
}
         675  +
impl GetPatchBaselineOutput {
         676  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         677  +
        self._request_id = request_id;
         678  +
        self
         679  +
    }
         680  +
}
         681  +
impl GetPatchBaselineOutput {
         682  +
    /// Creates a new builder-style object to manufacture [`GetPatchBaselineOutput`](crate::operation::get_patch_baseline::GetPatchBaselineOutput).
         683  +
    pub fn builder() -> crate::operation::get_patch_baseline::builders::GetPatchBaselineOutputBuilder {
         684  +
        crate::operation::get_patch_baseline::builders::GetPatchBaselineOutputBuilder::default()
         685  +
    }
         686  +
}
         687  +
         688  +
/// A builder for [`GetPatchBaselineOutput`](crate::operation::get_patch_baseline::GetPatchBaselineOutput).
         689  +
#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
         690  +
#[non_exhaustive]
         691  +
pub struct GetPatchBaselineOutputBuilder {
         692  +
    pub(crate) baseline_id: ::std::option::Option<::std::string::String>,
         693  +
    pub(crate) name: ::std::option::Option<::std::string::String>,
         694  +
    pub(crate) operating_system: ::std::option::Option<crate::types::OperatingSystem>,
         695  +
    pub(crate) global_filters: ::std::option::Option<crate::types::PatchFilterGroup>,
         696  +
    pub(crate) approval_rules: ::std::option::Option<crate::types::PatchRuleGroup>,
         697  +
    pub(crate) approved_patches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         698  +
    pub(crate) approved_patches_compliance_level: ::std::option::Option<crate::types::PatchComplianceLevel>,
         699  +
    pub(crate) approved_patches_enable_non_security: ::std::option::Option<bool>,
         700  +
    pub(crate) rejected_patches: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         701  +
    pub(crate) rejected_patches_action: ::std::option::Option<crate::types::PatchAction>,
         702  +
    pub(crate) patch_groups: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         703  +
    pub(crate) created_date: ::std::option::Option<::aws_smithy_types::DateTime>,
         704  +
    pub(crate) modified_date: ::std::option::Option<::aws_smithy_types::DateTime>,
         705  +
    pub(crate) description: ::std::option::Option<::std::string::String>,
         706  +
    pub(crate) sources: ::std::option::Option<::std::vec::Vec<crate::types::PatchSource>>,
         707  +
    pub(crate) available_security_updates_compliance_status: ::std::option::Option<crate::types::PatchComplianceStatus>,
         708  +
    _request_id: Option<String>,
         709  +
}
         710  +
impl GetPatchBaselineOutputBuilder {
         711  +
    /// <p>The ID of the retrieved patch baseline.</p>
         712  +
    pub fn baseline_id(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         713  +
        self.baseline_id = ::std::option::Option::Some(input.into());
         714  +
        self
         715  +
    }
         716  +
    /// <p>The ID of the retrieved patch baseline.</p>
         717  +
    pub fn set_baseline_id(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         718  +
        self.baseline_id = input;
         719  +
        self
         720  +
    }
         721  +
    /// <p>The ID of the retrieved patch baseline.</p>
         722  +
    pub fn get_baseline_id(&self) -> &::std::option::Option<::std::string::String> {
         723  +
        &self.baseline_id
         724  +
    }
         725  +
    /// <p>The name of the patch baseline.</p>
         726  +
    pub fn name(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         727  +
        self.name = ::std::option::Option::Some(input.into());
         728  +
        self
         729  +
    }
         730  +
    /// <p>The name of the patch baseline.</p>
         731  +
    pub fn set_name(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         732  +
        self.name = input;
         733  +
        self
         734  +
    }
         735  +
    /// <p>The name of the patch baseline.</p>
         736  +
    pub fn get_name(&self) -> &::std::option::Option<::std::string::String> {
         737  +
        &self.name
         738  +
    }
         739  +
    /// <p>Returns the operating system specified for the patch baseline.</p>
         740  +
    pub fn operating_system(mut self, input: crate::types::OperatingSystem) -> Self {
         741  +
        self.operating_system = ::std::option::Option::Some(input);
         742  +
        self
         743  +
    }
         744  +
    /// <p>Returns the operating system specified for the patch baseline.</p>
         745  +
    pub fn set_operating_system(mut self, input: ::std::option::Option<crate::types::OperatingSystem>) -> Self {
         746  +
        self.operating_system = input;
         747  +
        self
         748  +
    }
         749  +
    /// <p>Returns the operating system specified for the patch baseline.</p>
         750  +
    pub fn get_operating_system(&self) -> &::std::option::Option<crate::types::OperatingSystem> {
         751  +
        &self.operating_system
         752  +
    }
         753  +
    /// <p>A set of global filters used to exclude patches from the baseline.</p>
         754  +
    pub fn global_filters(mut self, input: crate::types::PatchFilterGroup) -> Self {
         755  +
        self.global_filters = ::std::option::Option::Some(input);
         756  +
        self
         757  +
    }
         758  +
    /// <p>A set of global filters used to exclude patches from the baseline.</p>
         759  +
    pub fn set_global_filters(mut self, input: ::std::option::Option<crate::types::PatchFilterGroup>) -> Self {
         760  +
        self.global_filters = input;
         761  +
        self
         762  +
    }
         763  +
    /// <p>A set of global filters used to exclude patches from the baseline.</p>
         764  +
    pub fn get_global_filters(&self) -> &::std::option::Option<crate::types::PatchFilterGroup> {
         765  +
        &self.global_filters
         766  +
    }
         767  +
    /// <p>A set of rules used to include patches in the baseline.</p>
         768  +
    pub fn approval_rules(mut self, input: crate::types::PatchRuleGroup) -> Self {
         769  +
        self.approval_rules = ::std::option::Option::Some(input);
         770  +
        self
         771  +
    }
         772  +
    /// <p>A set of rules used to include patches in the baseline.</p>
         773  +
    pub fn set_approval_rules(mut self, input: ::std::option::Option<crate::types::PatchRuleGroup>) -> Self {
         774  +
        self.approval_rules = input;
         775  +
        self
         776  +
    }
         777  +
    /// <p>A set of rules used to include patches in the baseline.</p>
         778  +
    pub fn get_approval_rules(&self) -> &::std::option::Option<crate::types::PatchRuleGroup> {
         779  +
        &self.approval_rules
         780  +
    }
         781  +
    /// Appends an item to `approved_patches`.
         782  +
    ///
         783  +
    /// To override the contents of this collection use [`set_approved_patches`](Self::set_approved_patches).
         784  +
    ///
         785  +
    /// <p>A list of explicitly approved patches for the baseline.</p>
         786  +
    pub fn approved_patches(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         787  +
        let mut v = self.approved_patches.unwrap_or_default();
         788  +
        v.push(input.into());
         789  +
        self.approved_patches = ::std::option::Option::Some(v);
         790  +
        self
         791  +
    }
         792  +
    /// <p>A list of explicitly approved patches for the baseline.</p>
         793  +
    pub fn set_approved_patches(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         794  +
        self.approved_patches = input;
         795  +
        self
         796  +
    }
         797  +
    /// <p>A list of explicitly approved patches for the baseline.</p>
         798  +
    pub fn get_approved_patches(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         799  +
        &self.approved_patches
         800  +
    }
         801  +
    /// <p>Returns the specified compliance severity level for approved patches in the patch baseline.</p>
         802  +
    pub fn approved_patches_compliance_level(mut self, input: crate::types::PatchComplianceLevel) -> Self {
         803  +
        self.approved_patches_compliance_level = ::std::option::Option::Some(input);
         804  +
        self
         805  +
    }
         806  +
    /// <p>Returns the specified compliance severity level for approved patches in the patch baseline.</p>
         807  +
    pub fn set_approved_patches_compliance_level(mut self, input: ::std::option::Option<crate::types::PatchComplianceLevel>) -> Self {
         808  +
        self.approved_patches_compliance_level = input;
         809  +
        self
         810  +
    }
         811  +
    /// <p>Returns the specified compliance severity level for approved patches in the patch baseline.</p>
         812  +
    pub fn get_approved_patches_compliance_level(&self) -> &::std::option::Option<crate::types::PatchComplianceLevel> {
         813  +
        &self.approved_patches_compliance_level
         814  +
    }
         815  +
    /// <p>Indicates whether the list of approved patches includes non-security updates that should be applied to the managed nodes. The default value is <code>false</code>. Applies to Linux managed nodes only.</p>
         816  +
    pub fn approved_patches_enable_non_security(mut self, input: bool) -> Self {
         817  +
        self.approved_patches_enable_non_security = ::std::option::Option::Some(input);
         818  +
        self
         819  +
    }
         820  +
    /// <p>Indicates whether the list of approved patches includes non-security updates that should be applied to the managed nodes. The default value is <code>false</code>. Applies to Linux managed nodes only.</p>
         821  +
    pub fn set_approved_patches_enable_non_security(mut self, input: ::std::option::Option<bool>) -> Self {
         822  +
        self.approved_patches_enable_non_security = input;
         823  +
        self
         824  +
    }
         825  +
    /// <p>Indicates whether the list of approved patches includes non-security updates that should be applied to the managed nodes. The default value is <code>false</code>. Applies to Linux managed nodes only.</p>
         826  +
    pub fn get_approved_patches_enable_non_security(&self) -> &::std::option::Option<bool> {
         827  +
        &self.approved_patches_enable_non_security
         828  +
    }
         829  +
    /// Appends an item to `rejected_patches`.
         830  +
    ///
         831  +
    /// To override the contents of this collection use [`set_rejected_patches`](Self::set_rejected_patches).
         832  +
    ///
         833  +
    /// <p>A list of explicitly rejected patches for the baseline.</p>
         834  +
    pub fn rejected_patches(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         835  +
        let mut v = self.rejected_patches.unwrap_or_default();
         836  +
        v.push(input.into());
         837  +
        self.rejected_patches = ::std::option::Option::Some(v);
         838  +
        self
         839  +
    }
         840  +
    /// <p>A list of explicitly rejected patches for the baseline.</p>
         841  +
    pub fn set_rejected_patches(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         842  +
        self.rejected_patches = input;
         843  +
        self
         844  +
    }
         845  +
    /// <p>A list of explicitly rejected patches for the baseline.</p>
         846  +
    pub fn get_rejected_patches(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         847  +
        &self.rejected_patches
         848  +
    }
         849  +
    /// <p>The action specified to take on patches included in the <code>RejectedPatches</code> list. A patch can be allowed only if it is a dependency of another package, or blocked entirely along with packages that include it as a dependency.</p>
         850  +
    pub fn rejected_patches_action(mut self, input: crate::types::PatchAction) -> Self {
         851  +
        self.rejected_patches_action = ::std::option::Option::Some(input);
         852  +
        self
         853  +
    }
         854  +
    /// <p>The action specified to take on patches included in the <code>RejectedPatches</code> list. A patch can be allowed only if it is a dependency of another package, or blocked entirely along with packages that include it as a dependency.</p>
         855  +
    pub fn set_rejected_patches_action(mut self, input: ::std::option::Option<crate::types::PatchAction>) -> Self {
         856  +
        self.rejected_patches_action = input;
         857  +
        self
         858  +
    }
         859  +
    /// <p>The action specified to take on patches included in the <code>RejectedPatches</code> list. A patch can be allowed only if it is a dependency of another package, or blocked entirely along with packages that include it as a dependency.</p>
         860  +
    pub fn get_rejected_patches_action(&self) -> &::std::option::Option<crate::types::PatchAction> {
         861  +
        &self.rejected_patches_action
         862  +
    }
         863  +
    /// Appends an item to `patch_groups`.
         864  +
    ///
         865  +
    /// To override the contents of this collection use [`set_patch_groups`](Self::set_patch_groups).
         866  +
    ///
         867  +
    /// <p>Patch groups included in the patch baseline.</p>
         868  +
    pub fn patch_groups(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         869  +
        let mut v = self.patch_groups.unwrap_or_default();
         870  +
        v.push(input.into());
         871  +
        self.patch_groups = ::std::option::Option::Some(v);
         872  +
        self
         873  +
    }
         874  +
    /// <p>Patch groups included in the patch baseline.</p>
         875  +
    pub fn set_patch_groups(mut self, input: ::std::option::Option<::std::vec::Vec<::std::string::String>>) -> Self {
         876  +
        self.patch_groups = input;
         877  +
        self
         878  +
    }
         879  +
    /// <p>Patch groups included in the patch baseline.</p>
         880  +
    pub fn get_patch_groups(&self) -> &::std::option::Option<::std::vec::Vec<::std::string::String>> {
         881  +
        &self.patch_groups
         882  +
    }
         883  +
    /// <p>The date the patch baseline was created.</p>
         884  +
    pub fn created_date(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         885  +
        self.created_date = ::std::option::Option::Some(input);
         886  +
        self
         887  +
    }
         888  +
    /// <p>The date the patch baseline was created.</p>
         889  +
    pub fn set_created_date(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         890  +
        self.created_date = input;
         891  +
        self
         892  +
    }
         893  +
    /// <p>The date the patch baseline was created.</p>
         894  +
    pub fn get_created_date(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         895  +
        &self.created_date
         896  +
    }
         897  +
    /// <p>The date the patch baseline was last modified.</p>
         898  +
    pub fn modified_date(mut self, input: ::aws_smithy_types::DateTime) -> Self {
         899  +
        self.modified_date = ::std::option::Option::Some(input);
         900  +
        self
         901  +
    }
         902  +
    /// <p>The date the patch baseline was last modified.</p>
         903  +
    pub fn set_modified_date(mut self, input: ::std::option::Option<::aws_smithy_types::DateTime>) -> Self {
         904  +
        self.modified_date = input;
         905  +
        self
         906  +
    }
         907  +
    /// <p>The date the patch baseline was last modified.</p>
         908  +
    pub fn get_modified_date(&self) -> &::std::option::Option<::aws_smithy_types::DateTime> {
         909  +
        &self.modified_date
         910  +
    }
         911  +
    /// <p>A description of the patch baseline.</p>
         912  +
    pub fn description(mut self, input: impl ::std::convert::Into<::std::string::String>) -> Self {
         913  +
        self.description = ::std::option::Option::Some(input.into());
         914  +
        self
         915  +
    }
         916  +
    /// <p>A description of the patch baseline.</p>
         917  +
    pub fn set_description(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         918  +
        self.description = input;
         919  +
        self
         920  +
    }
         921  +
    /// <p>A description of the patch baseline.</p>
         922  +
    pub fn get_description(&self) -> &::std::option::Option<::std::string::String> {
         923  +
        &self.description
         924  +
    }
         925  +
    /// Appends an item to `sources`.
         926  +
    ///
         927  +
    /// To override the contents of this collection use [`set_sources`](Self::set_sources).
         928  +
    ///
         929  +
    /// <p>Information about the patches to use to update the managed nodes, including target operating systems and source repositories. Applies to Linux managed nodes only.</p>
         930  +
    pub fn sources(mut self, input: crate::types::PatchSource) -> Self {
         931  +
        let mut v = self.sources.unwrap_or_default();
         932  +
        v.push(input);
         933  +
        self.sources = ::std::option::Option::Some(v);
         934  +
        self
         935  +
    }
         936  +
    /// <p>Information about the patches to use to update the managed nodes, including target operating systems and source repositories. Applies to Linux managed nodes only.</p>
         937  +
    pub fn set_sources(mut self, input: ::std::option::Option<::std::vec::Vec<crate::types::PatchSource>>) -> Self {
         938  +
        self.sources = input;
         939  +
        self
         940  +
    }
         941  +
    /// <p>Information about the patches to use to update the managed nodes, including target operating systems and source repositories. Applies to Linux managed nodes only.</p>
         942  +
    pub fn get_sources(&self) -> &::std::option::Option<::std::vec::Vec<crate::types::PatchSource>> {
         943  +
        &self.sources
         944  +
    }
         945  +
    /// <p>Indicates the compliance status of managed nodes for which security-related patches are available but were not approved. This preference is specified when the <code>CreatePatchBaseline</code> or <code>UpdatePatchBaseline</code> commands are run.</p>
         946  +
    /// <p>Applies to Windows Server managed nodes only.</p>
         947  +
    pub fn available_security_updates_compliance_status(mut self, input: crate::types::PatchComplianceStatus) -> Self {
         948  +
        self.available_security_updates_compliance_status = ::std::option::Option::Some(input);
         949  +
        self
         950  +
    }
         951  +
    /// <p>Indicates the compliance status of managed nodes for which security-related patches are available but were not approved. This preference is specified when the <code>CreatePatchBaseline</code> or <code>UpdatePatchBaseline</code> commands are run.</p>
         952  +
    /// <p>Applies to Windows Server managed nodes only.</p>
         953  +
    pub fn set_available_security_updates_compliance_status(mut self, input: ::std::option::Option<crate::types::PatchComplianceStatus>) -> Self {
         954  +
        self.available_security_updates_compliance_status = input;
         955  +
        self
         956  +
    }
         957  +
    /// <p>Indicates the compliance status of managed nodes for which security-related patches are available but were not approved. This preference is specified when the <code>CreatePatchBaseline</code> or <code>UpdatePatchBaseline</code> commands are run.</p>
         958  +
    /// <p>Applies to Windows Server managed nodes only.</p>
         959  +
    pub fn get_available_security_updates_compliance_status(&self) -> &::std::option::Option<crate::types::PatchComplianceStatus> {
         960  +
        &self.available_security_updates_compliance_status
         961  +
    }
         962  +
    pub(crate) fn _request_id(mut self, request_id: impl Into<String>) -> Self {
         963  +
        self._request_id = Some(request_id.into());
         964  +
        self
         965  +
    }
         966  +
         967  +
    pub(crate) fn _set_request_id(&mut self, request_id: Option<String>) -> &mut Self {
         968  +
        self._request_id = request_id;
         969  +
        self
         970  +
    }
         971  +
    /// Consumes the builder and constructs a [`GetPatchBaselineOutput`](crate::operation::get_patch_baseline::GetPatchBaselineOutput).
         972  +
    pub fn build(self) -> crate::operation::get_patch_baseline::GetPatchBaselineOutput {
         973  +
        crate::operation::get_patch_baseline::GetPatchBaselineOutput {
         974  +
            baseline_id: self.baseline_id,
         975  +
            name: self.name,
         976  +
            operating_system: self.operating_system,
         977  +
            global_filters: self.global_filters,
         978  +
            approval_rules: self.approval_rules,
         979  +
            approved_patches: self.approved_patches,
         980  +
            approved_patches_compliance_level: self.approved_patches_compliance_level,
         981  +
            approved_patches_enable_non_security: self.approved_patches_enable_non_security,
         982  +
            rejected_patches: self.rejected_patches,
         983  +
            rejected_patches_action: self.rejected_patches_action,
         984  +
            patch_groups: self.patch_groups,
         985  +
            created_date: self.created_date,
         986  +
            modified_date: self.modified_date,
         987  +
            description: self.description,
         988  +
            sources: self.sources,
         989  +
            available_security_updates_compliance_status: self.available_security_updates_compliance_status,
         990  +
            _request_id: self._request_id,
         991  +
        }
         992  +
    }
         993  +
}