// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UntagResourceOutput {}
impl std::fmt::Debug for UntagResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UntagResourceOutput");
        formatter.finish()
    }
}
/// See [`UntagResourceOutput`](crate::output::UntagResourceOutput)
pub mod untag_resource_output {
    /// A builder for [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`UntagResourceOutput`](crate::output::UntagResourceOutput)
        pub fn build(self) -> crate::output::UntagResourceOutput {
            crate::output::UntagResourceOutput {}
        }
    }
}
impl UntagResourceOutput {
    /// Creates a new builder-style object to manufacture [`UntagResourceOutput`](crate::output::UntagResourceOutput)
    pub fn builder() -> crate::output::untag_resource_output::Builder {
        crate::output::untag_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TagResourceOutput {}
impl std::fmt::Debug for TagResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("TagResourceOutput");
        formatter.finish()
    }
}
/// See [`TagResourceOutput`](crate::output::TagResourceOutput)
pub mod tag_resource_output {
    /// A builder for [`TagResourceOutput`](crate::output::TagResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`TagResourceOutput`](crate::output::TagResourceOutput)
        pub fn build(self) -> crate::output::TagResourceOutput {
            crate::output::TagResourceOutput {}
        }
    }
}
impl TagResourceOutput {
    /// Creates a new builder-style object to manufacture [`TagResourceOutput`](crate::output::TagResourceOutput)
    pub fn builder() -> crate::output::tag_resource_output::Builder {
        crate::output::tag_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StopConfigurationRecorderOutput {}
impl std::fmt::Debug for StopConfigurationRecorderOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StopConfigurationRecorderOutput");
        formatter.finish()
    }
}
/// See [`StopConfigurationRecorderOutput`](crate::output::StopConfigurationRecorderOutput)
pub mod stop_configuration_recorder_output {
    /// A builder for [`StopConfigurationRecorderOutput`](crate::output::StopConfigurationRecorderOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`StopConfigurationRecorderOutput`](crate::output::StopConfigurationRecorderOutput)
        pub fn build(self) -> crate::output::StopConfigurationRecorderOutput {
            crate::output::StopConfigurationRecorderOutput {}
        }
    }
}
impl StopConfigurationRecorderOutput {
    /// Creates a new builder-style object to manufacture [`StopConfigurationRecorderOutput`](crate::output::StopConfigurationRecorderOutput)
    pub fn builder() -> crate::output::stop_configuration_recorder_output::Builder {
        crate::output::stop_configuration_recorder_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartRemediationExecutionOutput {
    /// <p>Returns a failure message. For example, the resource is already compliant.</p>
    pub failure_message: std::option::Option<std::string::String>,
    /// <p>For resources that have failed to start execution, the API returns a resource key object.</p>
    pub failed_items: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
}
impl StartRemediationExecutionOutput {
    /// <p>Returns a failure message. For example, the resource is already compliant.</p>
    pub fn failure_message(&self) -> std::option::Option<&str> {
        self.failure_message.as_deref()
    }
    /// <p>For resources that have failed to start execution, the API returns a resource key object.</p>
    pub fn failed_items(&self) -> std::option::Option<&[crate::model::ResourceKey]> {
        self.failed_items.as_deref()
    }
}
impl std::fmt::Debug for StartRemediationExecutionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartRemediationExecutionOutput");
        formatter.field("failure_message", &self.failure_message);
        formatter.field("failed_items", &self.failed_items);
        formatter.finish()
    }
}
/// See [`StartRemediationExecutionOutput`](crate::output::StartRemediationExecutionOutput)
pub mod start_remediation_execution_output {
    /// A builder for [`StartRemediationExecutionOutput`](crate::output::StartRemediationExecutionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failure_message: std::option::Option<std::string::String>,
        pub(crate) failed_items: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
    }
    impl Builder {
        /// <p>Returns a failure message. For example, the resource is already compliant.</p>
        pub fn failure_message(mut self, input: impl Into<std::string::String>) -> Self {
            self.failure_message = Some(input.into());
            self
        }
        /// <p>Returns a failure message. For example, the resource is already compliant.</p>
        pub fn set_failure_message(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.failure_message = input;
            self
        }
        /// Appends an item to `failed_items`.
        ///
        /// To override the contents of this collection use [`set_failed_items`](Self::set_failed_items).
        ///
        /// <p>For resources that have failed to start execution, the API returns a resource key object.</p>
        pub fn failed_items(mut self, input: crate::model::ResourceKey) -> Self {
            let mut v = self.failed_items.unwrap_or_default();
            v.push(input);
            self.failed_items = Some(v);
            self
        }
        /// <p>For resources that have failed to start execution, the API returns a resource key object.</p>
        pub fn set_failed_items(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
        ) -> Self {
            self.failed_items = input;
            self
        }
        /// Consumes the builder and constructs a [`StartRemediationExecutionOutput`](crate::output::StartRemediationExecutionOutput)
        pub fn build(self) -> crate::output::StartRemediationExecutionOutput {
            crate::output::StartRemediationExecutionOutput {
                failure_message: self.failure_message,
                failed_items: self.failed_items,
            }
        }
    }
}
impl StartRemediationExecutionOutput {
    /// Creates a new builder-style object to manufacture [`StartRemediationExecutionOutput`](crate::output::StartRemediationExecutionOutput)
    pub fn builder() -> crate::output::start_remediation_execution_output::Builder {
        crate::output::start_remediation_execution_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartConfigurationRecorderOutput {}
impl std::fmt::Debug for StartConfigurationRecorderOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartConfigurationRecorderOutput");
        formatter.finish()
    }
}
/// See [`StartConfigurationRecorderOutput`](crate::output::StartConfigurationRecorderOutput)
pub mod start_configuration_recorder_output {
    /// A builder for [`StartConfigurationRecorderOutput`](crate::output::StartConfigurationRecorderOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`StartConfigurationRecorderOutput`](crate::output::StartConfigurationRecorderOutput)
        pub fn build(self) -> crate::output::StartConfigurationRecorderOutput {
            crate::output::StartConfigurationRecorderOutput {}
        }
    }
}
impl StartConfigurationRecorderOutput {
    /// Creates a new builder-style object to manufacture [`StartConfigurationRecorderOutput`](crate::output::StartConfigurationRecorderOutput)
    pub fn builder() -> crate::output::start_configuration_recorder_output::Builder {
        crate::output::start_configuration_recorder_output::Builder::default()
    }
}

/// <p>The output when you start the evaluation for the specified Config rule.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartConfigRulesEvaluationOutput {}
impl std::fmt::Debug for StartConfigRulesEvaluationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartConfigRulesEvaluationOutput");
        formatter.finish()
    }
}
/// See [`StartConfigRulesEvaluationOutput`](crate::output::StartConfigRulesEvaluationOutput)
pub mod start_config_rules_evaluation_output {
    /// A builder for [`StartConfigRulesEvaluationOutput`](crate::output::StartConfigRulesEvaluationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`StartConfigRulesEvaluationOutput`](crate::output::StartConfigRulesEvaluationOutput)
        pub fn build(self) -> crate::output::StartConfigRulesEvaluationOutput {
            crate::output::StartConfigRulesEvaluationOutput {}
        }
    }
}
impl StartConfigRulesEvaluationOutput {
    /// Creates a new builder-style object to manufacture [`StartConfigRulesEvaluationOutput`](crate::output::StartConfigRulesEvaluationOutput)
    pub fn builder() -> crate::output::start_config_rules_evaluation_output::Builder {
        crate::output::start_config_rules_evaluation_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SelectResourceConfigOutput {
    /// <p>Returns the results for the SQL query.</p>
    pub results: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Returns the <code>QueryInfo</code> object.</p>
    pub query_info: std::option::Option<crate::model::QueryInfo>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl SelectResourceConfigOutput {
    /// <p>Returns the results for the SQL query.</p>
    pub fn results(&self) -> std::option::Option<&[std::string::String]> {
        self.results.as_deref()
    }
    /// <p>Returns the <code>QueryInfo</code> object.</p>
    pub fn query_info(&self) -> std::option::Option<&crate::model::QueryInfo> {
        self.query_info.as_ref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for SelectResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SelectResourceConfigOutput");
        formatter.field("results", &self.results);
        formatter.field("query_info", &self.query_info);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`SelectResourceConfigOutput`](crate::output::SelectResourceConfigOutput)
pub mod select_resource_config_output {
    /// A builder for [`SelectResourceConfigOutput`](crate::output::SelectResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) results: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) query_info: std::option::Option<crate::model::QueryInfo>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `results`.
        ///
        /// To override the contents of this collection use [`set_results`](Self::set_results).
        ///
        /// <p>Returns the results for the SQL query.</p>
        pub fn results(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.results.unwrap_or_default();
            v.push(input.into());
            self.results = Some(v);
            self
        }
        /// <p>Returns the results for the SQL query.</p>
        pub fn set_results(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.results = input;
            self
        }
        /// <p>Returns the <code>QueryInfo</code> object.</p>
        pub fn query_info(mut self, input: crate::model::QueryInfo) -> Self {
            self.query_info = Some(input);
            self
        }
        /// <p>Returns the <code>QueryInfo</code> object.</p>
        pub fn set_query_info(
            mut self,
            input: std::option::Option<crate::model::QueryInfo>,
        ) -> Self {
            self.query_info = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`SelectResourceConfigOutput`](crate::output::SelectResourceConfigOutput)
        pub fn build(self) -> crate::output::SelectResourceConfigOutput {
            crate::output::SelectResourceConfigOutput {
                results: self.results,
                query_info: self.query_info,
                next_token: self.next_token,
            }
        }
    }
}
impl SelectResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`SelectResourceConfigOutput`](crate::output::SelectResourceConfigOutput)
    pub fn builder() -> crate::output::select_resource_config_output::Builder {
        crate::output::select_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SelectAggregateResourceConfigOutput {
    /// <p>Returns the results for the SQL query.</p>
    pub results: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>Details about the query.</p>
    pub query_info: std::option::Option<crate::model::QueryInfo>,
    /// <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl SelectAggregateResourceConfigOutput {
    /// <p>Returns the results for the SQL query.</p>
    pub fn results(&self) -> std::option::Option<&[std::string::String]> {
        self.results.as_deref()
    }
    /// <p>Details about the query.</p>
    pub fn query_info(&self) -> std::option::Option<&crate::model::QueryInfo> {
        self.query_info.as_ref()
    }
    /// <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for SelectAggregateResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SelectAggregateResourceConfigOutput");
        formatter.field("results", &self.results);
        formatter.field("query_info", &self.query_info);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`SelectAggregateResourceConfigOutput`](crate::output::SelectAggregateResourceConfigOutput)
pub mod select_aggregate_resource_config_output {
    /// A builder for [`SelectAggregateResourceConfigOutput`](crate::output::SelectAggregateResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) results: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) query_info: std::option::Option<crate::model::QueryInfo>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `results`.
        ///
        /// To override the contents of this collection use [`set_results`](Self::set_results).
        ///
        /// <p>Returns the results for the SQL query.</p>
        pub fn results(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.results.unwrap_or_default();
            v.push(input.into());
            self.results = Some(v);
            self
        }
        /// <p>Returns the results for the SQL query.</p>
        pub fn set_results(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.results = input;
            self
        }
        /// <p>Details about the query.</p>
        pub fn query_info(mut self, input: crate::model::QueryInfo) -> Self {
            self.query_info = Some(input);
            self
        }
        /// <p>Details about the query.</p>
        pub fn set_query_info(
            mut self,
            input: std::option::Option<crate::model::QueryInfo>,
        ) -> Self {
            self.query_info = input;
            self
        }
        /// <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The nextToken string returned in a previous request that you use to request the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`SelectAggregateResourceConfigOutput`](crate::output::SelectAggregateResourceConfigOutput)
        pub fn build(self) -> crate::output::SelectAggregateResourceConfigOutput {
            crate::output::SelectAggregateResourceConfigOutput {
                results: self.results,
                query_info: self.query_info,
                next_token: self.next_token,
            }
        }
    }
}
impl SelectAggregateResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`SelectAggregateResourceConfigOutput`](crate::output::SelectAggregateResourceConfigOutput)
    pub fn builder() -> crate::output::select_aggregate_resource_config_output::Builder {
        crate::output::select_aggregate_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutStoredQueryOutput {
    /// <p>Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.</p>
    pub query_arn: std::option::Option<std::string::String>,
}
impl PutStoredQueryOutput {
    /// <p>Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.</p>
    pub fn query_arn(&self) -> std::option::Option<&str> {
        self.query_arn.as_deref()
    }
}
impl std::fmt::Debug for PutStoredQueryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutStoredQueryOutput");
        formatter.field("query_arn", &self.query_arn);
        formatter.finish()
    }
}
/// See [`PutStoredQueryOutput`](crate::output::PutStoredQueryOutput)
pub mod put_stored_query_output {
    /// A builder for [`PutStoredQueryOutput`](crate::output::PutStoredQueryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) query_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.</p>
        pub fn query_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.query_arn = Some(input.into());
            self
        }
        /// <p>Amazon Resource Name (ARN) of the query. For example, arn:partition:service:region:account-id:resource-type/resource-name/resource-id.</p>
        pub fn set_query_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.query_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`PutStoredQueryOutput`](crate::output::PutStoredQueryOutput)
        pub fn build(self) -> crate::output::PutStoredQueryOutput {
            crate::output::PutStoredQueryOutput {
                query_arn: self.query_arn,
            }
        }
    }
}
impl PutStoredQueryOutput {
    /// Creates a new builder-style object to manufacture [`PutStoredQueryOutput`](crate::output::PutStoredQueryOutput)
    pub fn builder() -> crate::output::put_stored_query_output::Builder {
        crate::output::put_stored_query_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutRetentionConfigurationOutput {
    /// <p>Returns a retention configuration object.</p>
    pub retention_configuration: std::option::Option<crate::model::RetentionConfiguration>,
}
impl PutRetentionConfigurationOutput {
    /// <p>Returns a retention configuration object.</p>
    pub fn retention_configuration(
        &self,
    ) -> std::option::Option<&crate::model::RetentionConfiguration> {
        self.retention_configuration.as_ref()
    }
}
impl std::fmt::Debug for PutRetentionConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutRetentionConfigurationOutput");
        formatter.field("retention_configuration", &self.retention_configuration);
        formatter.finish()
    }
}
/// See [`PutRetentionConfigurationOutput`](crate::output::PutRetentionConfigurationOutput)
pub mod put_retention_configuration_output {
    /// A builder for [`PutRetentionConfigurationOutput`](crate::output::PutRetentionConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) retention_configuration:
            std::option::Option<crate::model::RetentionConfiguration>,
    }
    impl Builder {
        /// <p>Returns a retention configuration object.</p>
        pub fn retention_configuration(
            mut self,
            input: crate::model::RetentionConfiguration,
        ) -> Self {
            self.retention_configuration = Some(input);
            self
        }
        /// <p>Returns a retention configuration object.</p>
        pub fn set_retention_configuration(
            mut self,
            input: std::option::Option<crate::model::RetentionConfiguration>,
        ) -> Self {
            self.retention_configuration = input;
            self
        }
        /// Consumes the builder and constructs a [`PutRetentionConfigurationOutput`](crate::output::PutRetentionConfigurationOutput)
        pub fn build(self) -> crate::output::PutRetentionConfigurationOutput {
            crate::output::PutRetentionConfigurationOutput {
                retention_configuration: self.retention_configuration,
            }
        }
    }
}
impl PutRetentionConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`PutRetentionConfigurationOutput`](crate::output::PutRetentionConfigurationOutput)
    pub fn builder() -> crate::output::put_retention_configuration_output::Builder {
        crate::output::put_retention_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutResourceConfigOutput {}
impl std::fmt::Debug for PutResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutResourceConfigOutput");
        formatter.finish()
    }
}
/// See [`PutResourceConfigOutput`](crate::output::PutResourceConfigOutput)
pub mod put_resource_config_output {
    /// A builder for [`PutResourceConfigOutput`](crate::output::PutResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`PutResourceConfigOutput`](crate::output::PutResourceConfigOutput)
        pub fn build(self) -> crate::output::PutResourceConfigOutput {
            crate::output::PutResourceConfigOutput {}
        }
    }
}
impl PutResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`PutResourceConfigOutput`](crate::output::PutResourceConfigOutput)
    pub fn builder() -> crate::output::put_resource_config_output::Builder {
        crate::output::put_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutRemediationExceptionsOutput {
    /// <p>Returns a list of failed remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
    pub failed_batches:
        std::option::Option<std::vec::Vec<crate::model::FailedRemediationExceptionBatch>>,
}
impl PutRemediationExceptionsOutput {
    /// <p>Returns a list of failed remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
    pub fn failed_batches(
        &self,
    ) -> std::option::Option<&[crate::model::FailedRemediationExceptionBatch]> {
        self.failed_batches.as_deref()
    }
}
impl std::fmt::Debug for PutRemediationExceptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutRemediationExceptionsOutput");
        formatter.field("failed_batches", &self.failed_batches);
        formatter.finish()
    }
}
/// See [`PutRemediationExceptionsOutput`](crate::output::PutRemediationExceptionsOutput)
pub mod put_remediation_exceptions_output {
    /// A builder for [`PutRemediationExceptionsOutput`](crate::output::PutRemediationExceptionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failed_batches:
            std::option::Option<std::vec::Vec<crate::model::FailedRemediationExceptionBatch>>,
    }
    impl Builder {
        /// Appends an item to `failed_batches`.
        ///
        /// To override the contents of this collection use [`set_failed_batches`](Self::set_failed_batches).
        ///
        /// <p>Returns a list of failed remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
        pub fn failed_batches(
            mut self,
            input: crate::model::FailedRemediationExceptionBatch,
        ) -> Self {
            let mut v = self.failed_batches.unwrap_or_default();
            v.push(input);
            self.failed_batches = Some(v);
            self
        }
        /// <p>Returns a list of failed remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
        pub fn set_failed_batches(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::FailedRemediationExceptionBatch>,
            >,
        ) -> Self {
            self.failed_batches = input;
            self
        }
        /// Consumes the builder and constructs a [`PutRemediationExceptionsOutput`](crate::output::PutRemediationExceptionsOutput)
        pub fn build(self) -> crate::output::PutRemediationExceptionsOutput {
            crate::output::PutRemediationExceptionsOutput {
                failed_batches: self.failed_batches,
            }
        }
    }
}
impl PutRemediationExceptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutRemediationExceptionsOutput`](crate::output::PutRemediationExceptionsOutput)
    pub fn builder() -> crate::output::put_remediation_exceptions_output::Builder {
        crate::output::put_remediation_exceptions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutRemediationConfigurationsOutput {
    /// <p>Returns a list of failed remediation batch objects.</p>
    pub failed_batches: std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
}
impl PutRemediationConfigurationsOutput {
    /// <p>Returns a list of failed remediation batch objects.</p>
    pub fn failed_batches(&self) -> std::option::Option<&[crate::model::FailedRemediationBatch]> {
        self.failed_batches.as_deref()
    }
}
impl std::fmt::Debug for PutRemediationConfigurationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutRemediationConfigurationsOutput");
        formatter.field("failed_batches", &self.failed_batches);
        formatter.finish()
    }
}
/// See [`PutRemediationConfigurationsOutput`](crate::output::PutRemediationConfigurationsOutput)
pub mod put_remediation_configurations_output {
    /// A builder for [`PutRemediationConfigurationsOutput`](crate::output::PutRemediationConfigurationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failed_batches:
            std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
    }
    impl Builder {
        /// Appends an item to `failed_batches`.
        ///
        /// To override the contents of this collection use [`set_failed_batches`](Self::set_failed_batches).
        ///
        /// <p>Returns a list of failed remediation batch objects.</p>
        pub fn failed_batches(mut self, input: crate::model::FailedRemediationBatch) -> Self {
            let mut v = self.failed_batches.unwrap_or_default();
            v.push(input);
            self.failed_batches = Some(v);
            self
        }
        /// <p>Returns a list of failed remediation batch objects.</p>
        pub fn set_failed_batches(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
        ) -> Self {
            self.failed_batches = input;
            self
        }
        /// Consumes the builder and constructs a [`PutRemediationConfigurationsOutput`](crate::output::PutRemediationConfigurationsOutput)
        pub fn build(self) -> crate::output::PutRemediationConfigurationsOutput {
            crate::output::PutRemediationConfigurationsOutput {
                failed_batches: self.failed_batches,
            }
        }
    }
}
impl PutRemediationConfigurationsOutput {
    /// Creates a new builder-style object to manufacture [`PutRemediationConfigurationsOutput`](crate::output::PutRemediationConfigurationsOutput)
    pub fn builder() -> crate::output::put_remediation_configurations_output::Builder {
        crate::output::put_remediation_configurations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutOrganizationConformancePackOutput {
    /// <p>ARN of the organization conformance pack.</p>
    pub organization_conformance_pack_arn: std::option::Option<std::string::String>,
}
impl PutOrganizationConformancePackOutput {
    /// <p>ARN of the organization conformance pack.</p>
    pub fn organization_conformance_pack_arn(&self) -> std::option::Option<&str> {
        self.organization_conformance_pack_arn.as_deref()
    }
}
impl std::fmt::Debug for PutOrganizationConformancePackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutOrganizationConformancePackOutput");
        formatter.field(
            "organization_conformance_pack_arn",
            &self.organization_conformance_pack_arn,
        );
        formatter.finish()
    }
}
/// See [`PutOrganizationConformancePackOutput`](crate::output::PutOrganizationConformancePackOutput)
pub mod put_organization_conformance_pack_output {
    /// A builder for [`PutOrganizationConformancePackOutput`](crate::output::PutOrganizationConformancePackOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_conformance_pack_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>ARN of the organization conformance pack.</p>
        pub fn organization_conformance_pack_arn(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.organization_conformance_pack_arn = Some(input.into());
            self
        }
        /// <p>ARN of the organization conformance pack.</p>
        pub fn set_organization_conformance_pack_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.organization_conformance_pack_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`PutOrganizationConformancePackOutput`](crate::output::PutOrganizationConformancePackOutput)
        pub fn build(self) -> crate::output::PutOrganizationConformancePackOutput {
            crate::output::PutOrganizationConformancePackOutput {
                organization_conformance_pack_arn: self.organization_conformance_pack_arn,
            }
        }
    }
}
impl PutOrganizationConformancePackOutput {
    /// Creates a new builder-style object to manufacture [`PutOrganizationConformancePackOutput`](crate::output::PutOrganizationConformancePackOutput)
    pub fn builder() -> crate::output::put_organization_conformance_pack_output::Builder {
        crate::output::put_organization_conformance_pack_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutOrganizationConfigRuleOutput {
    /// <p>The Amazon Resource Name (ARN) of an organization Config rule.</p>
    pub organization_config_rule_arn: std::option::Option<std::string::String>,
}
impl PutOrganizationConfigRuleOutput {
    /// <p>The Amazon Resource Name (ARN) of an organization Config rule.</p>
    pub fn organization_config_rule_arn(&self) -> std::option::Option<&str> {
        self.organization_config_rule_arn.as_deref()
    }
}
impl std::fmt::Debug for PutOrganizationConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutOrganizationConfigRuleOutput");
        formatter.field(
            "organization_config_rule_arn",
            &self.organization_config_rule_arn,
        );
        formatter.finish()
    }
}
/// See [`PutOrganizationConfigRuleOutput`](crate::output::PutOrganizationConfigRuleOutput)
pub mod put_organization_config_rule_output {
    /// A builder for [`PutOrganizationConfigRuleOutput`](crate::output::PutOrganizationConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_config_rule_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The Amazon Resource Name (ARN) of an organization Config rule.</p>
        pub fn organization_config_rule_arn(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.organization_config_rule_arn = Some(input.into());
            self
        }
        /// <p>The Amazon Resource Name (ARN) of an organization Config rule.</p>
        pub fn set_organization_config_rule_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.organization_config_rule_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`PutOrganizationConfigRuleOutput`](crate::output::PutOrganizationConfigRuleOutput)
        pub fn build(self) -> crate::output::PutOrganizationConfigRuleOutput {
            crate::output::PutOrganizationConfigRuleOutput {
                organization_config_rule_arn: self.organization_config_rule_arn,
            }
        }
    }
}
impl PutOrganizationConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`PutOrganizationConfigRuleOutput`](crate::output::PutOrganizationConfigRuleOutput)
    pub fn builder() -> crate::output::put_organization_config_rule_output::Builder {
        crate::output::put_organization_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutExternalEvaluationOutput {}
impl std::fmt::Debug for PutExternalEvaluationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutExternalEvaluationOutput");
        formatter.finish()
    }
}
/// See [`PutExternalEvaluationOutput`](crate::output::PutExternalEvaluationOutput)
pub mod put_external_evaluation_output {
    /// A builder for [`PutExternalEvaluationOutput`](crate::output::PutExternalEvaluationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`PutExternalEvaluationOutput`](crate::output::PutExternalEvaluationOutput)
        pub fn build(self) -> crate::output::PutExternalEvaluationOutput {
            crate::output::PutExternalEvaluationOutput {}
        }
    }
}
impl PutExternalEvaluationOutput {
    /// Creates a new builder-style object to manufacture [`PutExternalEvaluationOutput`](crate::output::PutExternalEvaluationOutput)
    pub fn builder() -> crate::output::put_external_evaluation_output::Builder {
        crate::output::put_external_evaluation_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEvaluationsOutput {
    /// <p>Requests that failed because of a client or server error.</p>
    pub failed_evaluations: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
}
impl PutEvaluationsOutput {
    /// <p>Requests that failed because of a client or server error.</p>
    pub fn failed_evaluations(&self) -> std::option::Option<&[crate::model::Evaluation]> {
        self.failed_evaluations.as_deref()
    }
}
impl std::fmt::Debug for PutEvaluationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEvaluationsOutput");
        formatter.field("failed_evaluations", &self.failed_evaluations);
        formatter.finish()
    }
}
/// See [`PutEvaluationsOutput`](crate::output::PutEvaluationsOutput)
pub mod put_evaluations_output {
    /// A builder for [`PutEvaluationsOutput`](crate::output::PutEvaluationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failed_evaluations: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
    }
    impl Builder {
        /// Appends an item to `failed_evaluations`.
        ///
        /// To override the contents of this collection use [`set_failed_evaluations`](Self::set_failed_evaluations).
        ///
        /// <p>Requests that failed because of a client or server error.</p>
        pub fn failed_evaluations(mut self, input: crate::model::Evaluation) -> Self {
            let mut v = self.failed_evaluations.unwrap_or_default();
            v.push(input);
            self.failed_evaluations = Some(v);
            self
        }
        /// <p>Requests that failed because of a client or server error.</p>
        pub fn set_failed_evaluations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
        ) -> Self {
            self.failed_evaluations = input;
            self
        }
        /// Consumes the builder and constructs a [`PutEvaluationsOutput`](crate::output::PutEvaluationsOutput)
        pub fn build(self) -> crate::output::PutEvaluationsOutput {
            crate::output::PutEvaluationsOutput {
                failed_evaluations: self.failed_evaluations,
            }
        }
    }
}
impl PutEvaluationsOutput {
    /// Creates a new builder-style object to manufacture [`PutEvaluationsOutput`](crate::output::PutEvaluationsOutput)
    pub fn builder() -> crate::output::put_evaluations_output::Builder {
        crate::output::put_evaluations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutDeliveryChannelOutput {}
impl std::fmt::Debug for PutDeliveryChannelOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutDeliveryChannelOutput");
        formatter.finish()
    }
}
/// See [`PutDeliveryChannelOutput`](crate::output::PutDeliveryChannelOutput)
pub mod put_delivery_channel_output {
    /// A builder for [`PutDeliveryChannelOutput`](crate::output::PutDeliveryChannelOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`PutDeliveryChannelOutput`](crate::output::PutDeliveryChannelOutput)
        pub fn build(self) -> crate::output::PutDeliveryChannelOutput {
            crate::output::PutDeliveryChannelOutput {}
        }
    }
}
impl PutDeliveryChannelOutput {
    /// Creates a new builder-style object to manufacture [`PutDeliveryChannelOutput`](crate::output::PutDeliveryChannelOutput)
    pub fn builder() -> crate::output::put_delivery_channel_output::Builder {
        crate::output::put_delivery_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConformancePackOutput {
    /// <p>ARN of the conformance pack.</p>
    pub conformance_pack_arn: std::option::Option<std::string::String>,
}
impl PutConformancePackOutput {
    /// <p>ARN of the conformance pack.</p>
    pub fn conformance_pack_arn(&self) -> std::option::Option<&str> {
        self.conformance_pack_arn.as_deref()
    }
}
impl std::fmt::Debug for PutConformancePackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConformancePackOutput");
        formatter.field("conformance_pack_arn", &self.conformance_pack_arn);
        formatter.finish()
    }
}
/// See [`PutConformancePackOutput`](crate::output::PutConformancePackOutput)
pub mod put_conformance_pack_output {
    /// A builder for [`PutConformancePackOutput`](crate::output::PutConformancePackOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_arn: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>ARN of the conformance pack.</p>
        pub fn conformance_pack_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.conformance_pack_arn = Some(input.into());
            self
        }
        /// <p>ARN of the conformance pack.</p>
        pub fn set_conformance_pack_arn(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.conformance_pack_arn = input;
            self
        }
        /// Consumes the builder and constructs a [`PutConformancePackOutput`](crate::output::PutConformancePackOutput)
        pub fn build(self) -> crate::output::PutConformancePackOutput {
            crate::output::PutConformancePackOutput {
                conformance_pack_arn: self.conformance_pack_arn,
            }
        }
    }
}
impl PutConformancePackOutput {
    /// Creates a new builder-style object to manufacture [`PutConformancePackOutput`](crate::output::PutConformancePackOutput)
    pub fn builder() -> crate::output::put_conformance_pack_output::Builder {
        crate::output::put_conformance_pack_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationRecorderOutput {}
impl std::fmt::Debug for PutConfigurationRecorderOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationRecorderOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationRecorderOutput`](crate::output::PutConfigurationRecorderOutput)
pub mod put_configuration_recorder_output {
    /// A builder for [`PutConfigurationRecorderOutput`](crate::output::PutConfigurationRecorderOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`PutConfigurationRecorderOutput`](crate::output::PutConfigurationRecorderOutput)
        pub fn build(self) -> crate::output::PutConfigurationRecorderOutput {
            crate::output::PutConfigurationRecorderOutput {}
        }
    }
}
impl PutConfigurationRecorderOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationRecorderOutput`](crate::output::PutConfigurationRecorderOutput)
    pub fn builder() -> crate::output::put_configuration_recorder_output::Builder {
        crate::output::put_configuration_recorder_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationAggregatorOutput {
    /// <p>Returns a ConfigurationAggregator object.</p>
    pub configuration_aggregator: std::option::Option<crate::model::ConfigurationAggregator>,
}
impl PutConfigurationAggregatorOutput {
    /// <p>Returns a ConfigurationAggregator object.</p>
    pub fn configuration_aggregator(
        &self,
    ) -> std::option::Option<&crate::model::ConfigurationAggregator> {
        self.configuration_aggregator.as_ref()
    }
}
impl std::fmt::Debug for PutConfigurationAggregatorOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationAggregatorOutput");
        formatter.field("configuration_aggregator", &self.configuration_aggregator);
        formatter.finish()
    }
}
/// See [`PutConfigurationAggregatorOutput`](crate::output::PutConfigurationAggregatorOutput)
pub mod put_configuration_aggregator_output {
    /// A builder for [`PutConfigurationAggregatorOutput`](crate::output::PutConfigurationAggregatorOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_aggregator:
            std::option::Option<crate::model::ConfigurationAggregator>,
    }
    impl Builder {
        /// <p>Returns a ConfigurationAggregator object.</p>
        pub fn configuration_aggregator(
            mut self,
            input: crate::model::ConfigurationAggregator,
        ) -> Self {
            self.configuration_aggregator = Some(input);
            self
        }
        /// <p>Returns a ConfigurationAggregator object.</p>
        pub fn set_configuration_aggregator(
            mut self,
            input: std::option::Option<crate::model::ConfigurationAggregator>,
        ) -> Self {
            self.configuration_aggregator = input;
            self
        }
        /// Consumes the builder and constructs a [`PutConfigurationAggregatorOutput`](crate::output::PutConfigurationAggregatorOutput)
        pub fn build(self) -> crate::output::PutConfigurationAggregatorOutput {
            crate::output::PutConfigurationAggregatorOutput {
                configuration_aggregator: self.configuration_aggregator,
            }
        }
    }
}
impl PutConfigurationAggregatorOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationAggregatorOutput`](crate::output::PutConfigurationAggregatorOutput)
    pub fn builder() -> crate::output::put_configuration_aggregator_output::Builder {
        crate::output::put_configuration_aggregator_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigRuleOutput {}
impl std::fmt::Debug for PutConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigRuleOutput");
        formatter.finish()
    }
}
/// See [`PutConfigRuleOutput`](crate::output::PutConfigRuleOutput)
pub mod put_config_rule_output {
    /// A builder for [`PutConfigRuleOutput`](crate::output::PutConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`PutConfigRuleOutput`](crate::output::PutConfigRuleOutput)
        pub fn build(self) -> crate::output::PutConfigRuleOutput {
            crate::output::PutConfigRuleOutput {}
        }
    }
}
impl PutConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigRuleOutput`](crate::output::PutConfigRuleOutput)
    pub fn builder() -> crate::output::put_config_rule_output::Builder {
        crate::output::put_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAggregationAuthorizationOutput {
    /// <p>Returns an AggregationAuthorization object. </p>
    pub aggregation_authorization: std::option::Option<crate::model::AggregationAuthorization>,
}
impl PutAggregationAuthorizationOutput {
    /// <p>Returns an AggregationAuthorization object. </p>
    pub fn aggregation_authorization(
        &self,
    ) -> std::option::Option<&crate::model::AggregationAuthorization> {
        self.aggregation_authorization.as_ref()
    }
}
impl std::fmt::Debug for PutAggregationAuthorizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAggregationAuthorizationOutput");
        formatter.field("aggregation_authorization", &self.aggregation_authorization);
        formatter.finish()
    }
}
/// See [`PutAggregationAuthorizationOutput`](crate::output::PutAggregationAuthorizationOutput)
pub mod put_aggregation_authorization_output {
    /// A builder for [`PutAggregationAuthorizationOutput`](crate::output::PutAggregationAuthorizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregation_authorization:
            std::option::Option<crate::model::AggregationAuthorization>,
    }
    impl Builder {
        /// <p>Returns an AggregationAuthorization object. </p>
        pub fn aggregation_authorization(
            mut self,
            input: crate::model::AggregationAuthorization,
        ) -> Self {
            self.aggregation_authorization = Some(input);
            self
        }
        /// <p>Returns an AggregationAuthorization object. </p>
        pub fn set_aggregation_authorization(
            mut self,
            input: std::option::Option<crate::model::AggregationAuthorization>,
        ) -> Self {
            self.aggregation_authorization = input;
            self
        }
        /// Consumes the builder and constructs a [`PutAggregationAuthorizationOutput`](crate::output::PutAggregationAuthorizationOutput)
        pub fn build(self) -> crate::output::PutAggregationAuthorizationOutput {
            crate::output::PutAggregationAuthorizationOutput {
                aggregation_authorization: self.aggregation_authorization,
            }
        }
    }
}
impl PutAggregationAuthorizationOutput {
    /// Creates a new builder-style object to manufacture [`PutAggregationAuthorizationOutput`](crate::output::PutAggregationAuthorizationOutput)
    pub fn builder() -> crate::output::put_aggregation_authorization_output::Builder {
        crate::output::put_aggregation_authorization_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>The tags for the resource.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsForResourceOutput {
    /// <p>The tags for the resource.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags for the resource.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>The tags for the resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput {
                tags: self.tags,
                next_token: self.next_token,
            }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListStoredQueriesOutput {
    /// <p>A list of <code>StoredQueryMetadata</code> objects.</p>
    pub stored_query_metadata:
        std::option::Option<std::vec::Vec<crate::model::StoredQueryMetadata>>,
    /// <p>If the previous paginated request didn't return all of the remaining results, the response object's <code>NextToken</code> parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's <code>NextToken</code> parameter. If there are no remaining results, the previous response object's <code>NextToken</code> parameter is set to <code>null</code>. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListStoredQueriesOutput {
    /// <p>A list of <code>StoredQueryMetadata</code> objects.</p>
    pub fn stored_query_metadata(
        &self,
    ) -> std::option::Option<&[crate::model::StoredQueryMetadata]> {
        self.stored_query_metadata.as_deref()
    }
    /// <p>If the previous paginated request didn't return all of the remaining results, the response object's <code>NextToken</code> parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's <code>NextToken</code> parameter. If there are no remaining results, the previous response object's <code>NextToken</code> parameter is set to <code>null</code>. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListStoredQueriesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListStoredQueriesOutput");
        formatter.field("stored_query_metadata", &self.stored_query_metadata);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListStoredQueriesOutput`](crate::output::ListStoredQueriesOutput)
pub mod list_stored_queries_output {
    /// A builder for [`ListStoredQueriesOutput`](crate::output::ListStoredQueriesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) stored_query_metadata:
            std::option::Option<std::vec::Vec<crate::model::StoredQueryMetadata>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `stored_query_metadata`.
        ///
        /// To override the contents of this collection use [`set_stored_query_metadata`](Self::set_stored_query_metadata).
        ///
        /// <p>A list of <code>StoredQueryMetadata</code> objects.</p>
        pub fn stored_query_metadata(mut self, input: crate::model::StoredQueryMetadata) -> Self {
            let mut v = self.stored_query_metadata.unwrap_or_default();
            v.push(input);
            self.stored_query_metadata = Some(v);
            self
        }
        /// <p>A list of <code>StoredQueryMetadata</code> objects.</p>
        pub fn set_stored_query_metadata(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::StoredQueryMetadata>>,
        ) -> Self {
            self.stored_query_metadata = input;
            self
        }
        /// <p>If the previous paginated request didn't return all of the remaining results, the response object's <code>NextToken</code> parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's <code>NextToken</code> parameter. If there are no remaining results, the previous response object's <code>NextToken</code> parameter is set to <code>null</code>. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>If the previous paginated request didn't return all of the remaining results, the response object's <code>NextToken</code> parameter value is set to a token. To retrieve the next set of results, call this action again and assign that token to the request object's <code>NextToken</code> parameter. If there are no remaining results, the previous response object's <code>NextToken</code> parameter is set to <code>null</code>. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListStoredQueriesOutput`](crate::output::ListStoredQueriesOutput)
        pub fn build(self) -> crate::output::ListStoredQueriesOutput {
            crate::output::ListStoredQueriesOutput {
                stored_query_metadata: self.stored_query_metadata,
                next_token: self.next_token,
            }
        }
    }
}
impl ListStoredQueriesOutput {
    /// Creates a new builder-style object to manufacture [`ListStoredQueriesOutput`](crate::output::ListStoredQueriesOutput)
    pub fn builder() -> crate::output::list_stored_queries_output::Builder {
        crate::output::list_stored_queries_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDiscoveredResourcesOutput {
    /// <p>The details that identify a resource that is discovered by Config, including the resource type, ID, and (if available) the custom resource name.</p>
    pub resource_identifiers: std::option::Option<std::vec::Vec<crate::model::ResourceIdentifier>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDiscoveredResourcesOutput {
    /// <p>The details that identify a resource that is discovered by Config, including the resource type, ID, and (if available) the custom resource name.</p>
    pub fn resource_identifiers(&self) -> std::option::Option<&[crate::model::ResourceIdentifier]> {
        self.resource_identifiers.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDiscoveredResourcesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDiscoveredResourcesOutput");
        formatter.field("resource_identifiers", &self.resource_identifiers);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDiscoveredResourcesOutput`](crate::output::ListDiscoveredResourcesOutput)
pub mod list_discovered_resources_output {
    /// A builder for [`ListDiscoveredResourcesOutput`](crate::output::ListDiscoveredResourcesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resource_identifiers:
            std::option::Option<std::vec::Vec<crate::model::ResourceIdentifier>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `resource_identifiers`.
        ///
        /// To override the contents of this collection use [`set_resource_identifiers`](Self::set_resource_identifiers).
        ///
        /// <p>The details that identify a resource that is discovered by Config, including the resource type, ID, and (if available) the custom resource name.</p>
        pub fn resource_identifiers(mut self, input: crate::model::ResourceIdentifier) -> Self {
            let mut v = self.resource_identifiers.unwrap_or_default();
            v.push(input);
            self.resource_identifiers = Some(v);
            self
        }
        /// <p>The details that identify a resource that is discovered by Config, including the resource type, ID, and (if available) the custom resource name.</p>
        pub fn set_resource_identifiers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourceIdentifier>>,
        ) -> Self {
            self.resource_identifiers = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDiscoveredResourcesOutput`](crate::output::ListDiscoveredResourcesOutput)
        pub fn build(self) -> crate::output::ListDiscoveredResourcesOutput {
            crate::output::ListDiscoveredResourcesOutput {
                resource_identifiers: self.resource_identifiers,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDiscoveredResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListDiscoveredResourcesOutput`](crate::output::ListDiscoveredResourcesOutput)
    pub fn builder() -> crate::output::list_discovered_resources_output::Builder {
        crate::output::list_discovered_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListAggregateDiscoveredResourcesOutput {
    /// <p>Returns a list of <code>ResourceIdentifiers</code> objects.</p>
    pub resource_identifiers:
        std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListAggregateDiscoveredResourcesOutput {
    /// <p>Returns a list of <code>ResourceIdentifiers</code> objects.</p>
    pub fn resource_identifiers(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateResourceIdentifier]> {
        self.resource_identifiers.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListAggregateDiscoveredResourcesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListAggregateDiscoveredResourcesOutput");
        formatter.field("resource_identifiers", &self.resource_identifiers);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListAggregateDiscoveredResourcesOutput`](crate::output::ListAggregateDiscoveredResourcesOutput)
pub mod list_aggregate_discovered_resources_output {
    /// A builder for [`ListAggregateDiscoveredResourcesOutput`](crate::output::ListAggregateDiscoveredResourcesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resource_identifiers:
            std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `resource_identifiers`.
        ///
        /// To override the contents of this collection use [`set_resource_identifiers`](Self::set_resource_identifiers).
        ///
        /// <p>Returns a list of <code>ResourceIdentifiers</code> objects.</p>
        pub fn resource_identifiers(
            mut self,
            input: crate::model::AggregateResourceIdentifier,
        ) -> Self {
            let mut v = self.resource_identifiers.unwrap_or_default();
            v.push(input);
            self.resource_identifiers = Some(v);
            self
        }
        /// <p>Returns a list of <code>ResourceIdentifiers</code> objects.</p>
        pub fn set_resource_identifiers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
        ) -> Self {
            self.resource_identifiers = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListAggregateDiscoveredResourcesOutput`](crate::output::ListAggregateDiscoveredResourcesOutput)
        pub fn build(self) -> crate::output::ListAggregateDiscoveredResourcesOutput {
            crate::output::ListAggregateDiscoveredResourcesOutput {
                resource_identifiers: self.resource_identifiers,
                next_token: self.next_token,
            }
        }
    }
}
impl ListAggregateDiscoveredResourcesOutput {
    /// Creates a new builder-style object to manufacture [`ListAggregateDiscoveredResourcesOutput`](crate::output::ListAggregateDiscoveredResourcesOutput)
    pub fn builder() -> crate::output::list_aggregate_discovered_resources_output::Builder {
        crate::output::list_aggregate_discovered_resources_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetStoredQueryOutput {
    /// <p>Returns a <code>StoredQuery</code> object.</p>
    pub stored_query: std::option::Option<crate::model::StoredQuery>,
}
impl GetStoredQueryOutput {
    /// <p>Returns a <code>StoredQuery</code> object.</p>
    pub fn stored_query(&self) -> std::option::Option<&crate::model::StoredQuery> {
        self.stored_query.as_ref()
    }
}
impl std::fmt::Debug for GetStoredQueryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetStoredQueryOutput");
        formatter.field("stored_query", &self.stored_query);
        formatter.finish()
    }
}
/// See [`GetStoredQueryOutput`](crate::output::GetStoredQueryOutput)
pub mod get_stored_query_output {
    /// A builder for [`GetStoredQueryOutput`](crate::output::GetStoredQueryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) stored_query: std::option::Option<crate::model::StoredQuery>,
    }
    impl Builder {
        /// <p>Returns a <code>StoredQuery</code> object.</p>
        pub fn stored_query(mut self, input: crate::model::StoredQuery) -> Self {
            self.stored_query = Some(input);
            self
        }
        /// <p>Returns a <code>StoredQuery</code> object.</p>
        pub fn set_stored_query(
            mut self,
            input: std::option::Option<crate::model::StoredQuery>,
        ) -> Self {
            self.stored_query = input;
            self
        }
        /// Consumes the builder and constructs a [`GetStoredQueryOutput`](crate::output::GetStoredQueryOutput)
        pub fn build(self) -> crate::output::GetStoredQueryOutput {
            crate::output::GetStoredQueryOutput {
                stored_query: self.stored_query,
            }
        }
    }
}
impl GetStoredQueryOutput {
    /// Creates a new builder-style object to manufacture [`GetStoredQueryOutput`](crate::output::GetStoredQueryOutput)
    pub fn builder() -> crate::output::get_stored_query_output::Builder {
        crate::output::get_stored_query_output::Builder::default()
    }
}

/// <p>The output for the <code>GetResourceConfigHistory</code> action.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetResourceConfigHistoryOutput {
    /// <p>A list that contains the configuration history of one or more resources.</p>
    pub configuration_items: std::option::Option<std::vec::Vec<crate::model::ConfigurationItem>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetResourceConfigHistoryOutput {
    /// <p>A list that contains the configuration history of one or more resources.</p>
    pub fn configuration_items(&self) -> std::option::Option<&[crate::model::ConfigurationItem]> {
        self.configuration_items.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetResourceConfigHistoryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetResourceConfigHistoryOutput");
        formatter.field("configuration_items", &self.configuration_items);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetResourceConfigHistoryOutput`](crate::output::GetResourceConfigHistoryOutput)
pub mod get_resource_config_history_output {
    /// A builder for [`GetResourceConfigHistoryOutput`](crate::output::GetResourceConfigHistoryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_items:
            std::option::Option<std::vec::Vec<crate::model::ConfigurationItem>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `configuration_items`.
        ///
        /// To override the contents of this collection use [`set_configuration_items`](Self::set_configuration_items).
        ///
        /// <p>A list that contains the configuration history of one or more resources.</p>
        pub fn configuration_items(mut self, input: crate::model::ConfigurationItem) -> Self {
            let mut v = self.configuration_items.unwrap_or_default();
            v.push(input);
            self.configuration_items = Some(v);
            self
        }
        /// <p>A list that contains the configuration history of one or more resources.</p>
        pub fn set_configuration_items(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigurationItem>>,
        ) -> Self {
            self.configuration_items = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetResourceConfigHistoryOutput`](crate::output::GetResourceConfigHistoryOutput)
        pub fn build(self) -> crate::output::GetResourceConfigHistoryOutput {
            crate::output::GetResourceConfigHistoryOutput {
                configuration_items: self.configuration_items,
                next_token: self.next_token,
            }
        }
    }
}
impl GetResourceConfigHistoryOutput {
    /// Creates a new builder-style object to manufacture [`GetResourceConfigHistoryOutput`](crate::output::GetResourceConfigHistoryOutput)
    pub fn builder() -> crate::output::get_resource_config_history_output::Builder {
        crate::output::get_resource_config_history_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetOrganizationCustomRulePolicyOutput {
    /// <p>The policy definition containing the logic for your organization Config Custom Policy rule.</p>
    pub policy_text: std::option::Option<std::string::String>,
}
impl GetOrganizationCustomRulePolicyOutput {
    /// <p>The policy definition containing the logic for your organization Config Custom Policy rule.</p>
    pub fn policy_text(&self) -> std::option::Option<&str> {
        self.policy_text.as_deref()
    }
}
impl std::fmt::Debug for GetOrganizationCustomRulePolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetOrganizationCustomRulePolicyOutput");
        formatter.field("policy_text", &self.policy_text);
        formatter.finish()
    }
}
/// See [`GetOrganizationCustomRulePolicyOutput`](crate::output::GetOrganizationCustomRulePolicyOutput)
pub mod get_organization_custom_rule_policy_output {
    /// A builder for [`GetOrganizationCustomRulePolicyOutput`](crate::output::GetOrganizationCustomRulePolicyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) policy_text: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The policy definition containing the logic for your organization Config Custom Policy rule.</p>
        pub fn policy_text(mut self, input: impl Into<std::string::String>) -> Self {
            self.policy_text = Some(input.into());
            self
        }
        /// <p>The policy definition containing the logic for your organization Config Custom Policy rule.</p>
        pub fn set_policy_text(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.policy_text = input;
            self
        }
        /// Consumes the builder and constructs a [`GetOrganizationCustomRulePolicyOutput`](crate::output::GetOrganizationCustomRulePolicyOutput)
        pub fn build(self) -> crate::output::GetOrganizationCustomRulePolicyOutput {
            crate::output::GetOrganizationCustomRulePolicyOutput {
                policy_text: self.policy_text,
            }
        }
    }
}
impl GetOrganizationCustomRulePolicyOutput {
    /// Creates a new builder-style object to manufacture [`GetOrganizationCustomRulePolicyOutput`](crate::output::GetOrganizationCustomRulePolicyOutput)
    pub fn builder() -> crate::output::get_organization_custom_rule_policy_output::Builder {
        crate::output::get_organization_custom_rule_policy_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetOrganizationConformancePackDetailedStatusOutput {
    /// <p>A list of <code>OrganizationConformancePackDetailedStatus</code> objects. </p>
    pub organization_conformance_pack_detailed_statuses:
        std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePackDetailedStatus>>,
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetOrganizationConformancePackDetailedStatusOutput {
    /// <p>A list of <code>OrganizationConformancePackDetailedStatus</code> objects. </p>
    pub fn organization_conformance_pack_detailed_statuses(
        &self,
    ) -> std::option::Option<&[crate::model::OrganizationConformancePackDetailedStatus]> {
        self.organization_conformance_pack_detailed_statuses
            .as_deref()
    }
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetOrganizationConformancePackDetailedStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetOrganizationConformancePackDetailedStatusOutput");
        formatter.field(
            "organization_conformance_pack_detailed_statuses",
            &self.organization_conformance_pack_detailed_statuses,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetOrganizationConformancePackDetailedStatusOutput`](crate::output::GetOrganizationConformancePackDetailedStatusOutput)
pub mod get_organization_conformance_pack_detailed_status_output {
    /// A builder for [`GetOrganizationConformancePackDetailedStatusOutput`](crate::output::GetOrganizationConformancePackDetailedStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_conformance_pack_detailed_statuses: std::option::Option<
            std::vec::Vec<crate::model::OrganizationConformancePackDetailedStatus>,
        >,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_conformance_pack_detailed_statuses`.
        ///
        /// To override the contents of this collection use [`set_organization_conformance_pack_detailed_statuses`](Self::set_organization_conformance_pack_detailed_statuses).
        ///
        /// <p>A list of <code>OrganizationConformancePackDetailedStatus</code> objects. </p>
        pub fn organization_conformance_pack_detailed_statuses(
            mut self,
            input: crate::model::OrganizationConformancePackDetailedStatus,
        ) -> Self {
            let mut v = self
                .organization_conformance_pack_detailed_statuses
                .unwrap_or_default();
            v.push(input);
            self.organization_conformance_pack_detailed_statuses = Some(v);
            self
        }
        /// <p>A list of <code>OrganizationConformancePackDetailedStatus</code> objects. </p>
        pub fn set_organization_conformance_pack_detailed_statuses(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::OrganizationConformancePackDetailedStatus>,
            >,
        ) -> Self {
            self.organization_conformance_pack_detailed_statuses = input;
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetOrganizationConformancePackDetailedStatusOutput`](crate::output::GetOrganizationConformancePackDetailedStatusOutput)
        pub fn build(self) -> crate::output::GetOrganizationConformancePackDetailedStatusOutput {
            crate::output::GetOrganizationConformancePackDetailedStatusOutput {
                organization_conformance_pack_detailed_statuses: self
                    .organization_conformance_pack_detailed_statuses,
                next_token: self.next_token,
            }
        }
    }
}
impl GetOrganizationConformancePackDetailedStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetOrganizationConformancePackDetailedStatusOutput`](crate::output::GetOrganizationConformancePackDetailedStatusOutput)
    pub fn builder(
    ) -> crate::output::get_organization_conformance_pack_detailed_status_output::Builder {
        crate::output::get_organization_conformance_pack_detailed_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetOrganizationConfigRuleDetailedStatusOutput {
    /// <p>A list of <code>MemberAccountStatus</code> objects.</p>
    pub organization_config_rule_detailed_status:
        std::option::Option<std::vec::Vec<crate::model::MemberAccountStatus>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetOrganizationConfigRuleDetailedStatusOutput {
    /// <p>A list of <code>MemberAccountStatus</code> objects.</p>
    pub fn organization_config_rule_detailed_status(
        &self,
    ) -> std::option::Option<&[crate::model::MemberAccountStatus]> {
        self.organization_config_rule_detailed_status.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetOrganizationConfigRuleDetailedStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetOrganizationConfigRuleDetailedStatusOutput");
        formatter.field(
            "organization_config_rule_detailed_status",
            &self.organization_config_rule_detailed_status,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetOrganizationConfigRuleDetailedStatusOutput`](crate::output::GetOrganizationConfigRuleDetailedStatusOutput)
pub mod get_organization_config_rule_detailed_status_output {
    /// A builder for [`GetOrganizationConfigRuleDetailedStatusOutput`](crate::output::GetOrganizationConfigRuleDetailedStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_config_rule_detailed_status:
            std::option::Option<std::vec::Vec<crate::model::MemberAccountStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_config_rule_detailed_status`.
        ///
        /// To override the contents of this collection use [`set_organization_config_rule_detailed_status`](Self::set_organization_config_rule_detailed_status).
        ///
        /// <p>A list of <code>MemberAccountStatus</code> objects.</p>
        pub fn organization_config_rule_detailed_status(
            mut self,
            input: crate::model::MemberAccountStatus,
        ) -> Self {
            let mut v = self
                .organization_config_rule_detailed_status
                .unwrap_or_default();
            v.push(input);
            self.organization_config_rule_detailed_status = Some(v);
            self
        }
        /// <p>A list of <code>MemberAccountStatus</code> objects.</p>
        pub fn set_organization_config_rule_detailed_status(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::MemberAccountStatus>>,
        ) -> Self {
            self.organization_config_rule_detailed_status = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetOrganizationConfigRuleDetailedStatusOutput`](crate::output::GetOrganizationConfigRuleDetailedStatusOutput)
        pub fn build(self) -> crate::output::GetOrganizationConfigRuleDetailedStatusOutput {
            crate::output::GetOrganizationConfigRuleDetailedStatusOutput {
                organization_config_rule_detailed_status: self
                    .organization_config_rule_detailed_status,
                next_token: self.next_token,
            }
        }
    }
}
impl GetOrganizationConfigRuleDetailedStatusOutput {
    /// Creates a new builder-style object to manufacture [`GetOrganizationConfigRuleDetailedStatusOutput`](crate::output::GetOrganizationConfigRuleDetailedStatusOutput)
    pub fn builder() -> crate::output::get_organization_config_rule_detailed_status_output::Builder
    {
        crate::output::get_organization_config_rule_detailed_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDiscoveredResourceCountsOutput {
    /// <p>The total number of resources that Config is recording in the region for your account. If you specify resource types in the request, Config returns only the total number of resources for those resource types.</p>
    /// <p class="title"> <b>Example</b> </p>
    /// <ol>
    /// <li> <p>Config is recording three resource types in the US East (Ohio) Region for your account: 25 EC2 instances, 20 IAM users, and 15 S3 buckets, for a total of 60 resources.</p> </li>
    /// <li> <p>You make a call to the <code>GetDiscoveredResourceCounts</code> action and specify the resource type, <code>"AWS::EC2::Instances"</code>, in the request.</p> </li>
    /// <li> <p>Config returns 25 for <code>totalDiscoveredResources</code>.</p> </li>
    /// </ol>
    pub total_discovered_resources: i64,
    /// <p>The list of <code>ResourceCount</code> objects. Each object is listed in descending order by the number of resources.</p>
    pub resource_counts: std::option::Option<std::vec::Vec<crate::model::ResourceCount>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetDiscoveredResourceCountsOutput {
    /// <p>The total number of resources that Config is recording in the region for your account. If you specify resource types in the request, Config returns only the total number of resources for those resource types.</p>
    /// <p class="title"> <b>Example</b> </p>
    /// <ol>
    /// <li> <p>Config is recording three resource types in the US East (Ohio) Region for your account: 25 EC2 instances, 20 IAM users, and 15 S3 buckets, for a total of 60 resources.</p> </li>
    /// <li> <p>You make a call to the <code>GetDiscoveredResourceCounts</code> action and specify the resource type, <code>"AWS::EC2::Instances"</code>, in the request.</p> </li>
    /// <li> <p>Config returns 25 for <code>totalDiscoveredResources</code>.</p> </li>
    /// </ol>
    pub fn total_discovered_resources(&self) -> i64 {
        self.total_discovered_resources
    }
    /// <p>The list of <code>ResourceCount</code> objects. Each object is listed in descending order by the number of resources.</p>
    pub fn resource_counts(&self) -> std::option::Option<&[crate::model::ResourceCount]> {
        self.resource_counts.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetDiscoveredResourceCountsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDiscoveredResourceCountsOutput");
        formatter.field(
            "total_discovered_resources",
            &self.total_discovered_resources,
        );
        formatter.field("resource_counts", &self.resource_counts);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetDiscoveredResourceCountsOutput`](crate::output::GetDiscoveredResourceCountsOutput)
pub mod get_discovered_resource_counts_output {
    /// A builder for [`GetDiscoveredResourceCountsOutput`](crate::output::GetDiscoveredResourceCountsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) total_discovered_resources: std::option::Option<i64>,
        pub(crate) resource_counts: std::option::Option<std::vec::Vec<crate::model::ResourceCount>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The total number of resources that Config is recording in the region for your account. If you specify resource types in the request, Config returns only the total number of resources for those resource types.</p>
        /// <p class="title"> <b>Example</b> </p>
        /// <ol>
        /// <li> <p>Config is recording three resource types in the US East (Ohio) Region for your account: 25 EC2 instances, 20 IAM users, and 15 S3 buckets, for a total of 60 resources.</p> </li>
        /// <li> <p>You make a call to the <code>GetDiscoveredResourceCounts</code> action and specify the resource type, <code>"AWS::EC2::Instances"</code>, in the request.</p> </li>
        /// <li> <p>Config returns 25 for <code>totalDiscoveredResources</code>.</p> </li>
        /// </ol>
        pub fn total_discovered_resources(mut self, input: i64) -> Self {
            self.total_discovered_resources = Some(input);
            self
        }
        /// <p>The total number of resources that Config is recording in the region for your account. If you specify resource types in the request, Config returns only the total number of resources for those resource types.</p>
        /// <p class="title"> <b>Example</b> </p>
        /// <ol>
        /// <li> <p>Config is recording three resource types in the US East (Ohio) Region for your account: 25 EC2 instances, 20 IAM users, and 15 S3 buckets, for a total of 60 resources.</p> </li>
        /// <li> <p>You make a call to the <code>GetDiscoveredResourceCounts</code> action and specify the resource type, <code>"AWS::EC2::Instances"</code>, in the request.</p> </li>
        /// <li> <p>Config returns 25 for <code>totalDiscoveredResources</code>.</p> </li>
        /// </ol>
        pub fn set_total_discovered_resources(mut self, input: std::option::Option<i64>) -> Self {
            self.total_discovered_resources = input;
            self
        }
        /// Appends an item to `resource_counts`.
        ///
        /// To override the contents of this collection use [`set_resource_counts`](Self::set_resource_counts).
        ///
        /// <p>The list of <code>ResourceCount</code> objects. Each object is listed in descending order by the number of resources.</p>
        pub fn resource_counts(mut self, input: crate::model::ResourceCount) -> Self {
            let mut v = self.resource_counts.unwrap_or_default();
            v.push(input);
            self.resource_counts = Some(v);
            self
        }
        /// <p>The list of <code>ResourceCount</code> objects. Each object is listed in descending order by the number of resources.</p>
        pub fn set_resource_counts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourceCount>>,
        ) -> Self {
            self.resource_counts = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDiscoveredResourceCountsOutput`](crate::output::GetDiscoveredResourceCountsOutput)
        pub fn build(self) -> crate::output::GetDiscoveredResourceCountsOutput {
            crate::output::GetDiscoveredResourceCountsOutput {
                total_discovered_resources: self.total_discovered_resources.unwrap_or_default(),
                resource_counts: self.resource_counts,
                next_token: self.next_token,
            }
        }
    }
}
impl GetDiscoveredResourceCountsOutput {
    /// Creates a new builder-style object to manufacture [`GetDiscoveredResourceCountsOutput`](crate::output::GetDiscoveredResourceCountsOutput)
    pub fn builder() -> crate::output::get_discovered_resource_counts_output::Builder {
        crate::output::get_discovered_resource_counts_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetCustomRulePolicyOutput {
    /// <p>The policy definition containing the logic for your Config Custom Policy rule.</p>
    pub policy_text: std::option::Option<std::string::String>,
}
impl GetCustomRulePolicyOutput {
    /// <p>The policy definition containing the logic for your Config Custom Policy rule.</p>
    pub fn policy_text(&self) -> std::option::Option<&str> {
        self.policy_text.as_deref()
    }
}
impl std::fmt::Debug for GetCustomRulePolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetCustomRulePolicyOutput");
        formatter.field("policy_text", &self.policy_text);
        formatter.finish()
    }
}
/// See [`GetCustomRulePolicyOutput`](crate::output::GetCustomRulePolicyOutput)
pub mod get_custom_rule_policy_output {
    /// A builder for [`GetCustomRulePolicyOutput`](crate::output::GetCustomRulePolicyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) policy_text: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The policy definition containing the logic for your Config Custom Policy rule.</p>
        pub fn policy_text(mut self, input: impl Into<std::string::String>) -> Self {
            self.policy_text = Some(input.into());
            self
        }
        /// <p>The policy definition containing the logic for your Config Custom Policy rule.</p>
        pub fn set_policy_text(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.policy_text = input;
            self
        }
        /// Consumes the builder and constructs a [`GetCustomRulePolicyOutput`](crate::output::GetCustomRulePolicyOutput)
        pub fn build(self) -> crate::output::GetCustomRulePolicyOutput {
            crate::output::GetCustomRulePolicyOutput {
                policy_text: self.policy_text,
            }
        }
    }
}
impl GetCustomRulePolicyOutput {
    /// Creates a new builder-style object to manufacture [`GetCustomRulePolicyOutput`](crate::output::GetCustomRulePolicyOutput)
    pub fn builder() -> crate::output::get_custom_rule_policy_output::Builder {
        crate::output::get_custom_rule_policy_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConformancePackComplianceSummaryOutput {
    /// <p>A list of <code>ConformancePackComplianceSummary</code> objects. </p>
    pub conformance_pack_compliance_summary_list:
        std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceSummary>>,
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetConformancePackComplianceSummaryOutput {
    /// <p>A list of <code>ConformancePackComplianceSummary</code> objects. </p>
    pub fn conformance_pack_compliance_summary_list(
        &self,
    ) -> std::option::Option<&[crate::model::ConformancePackComplianceSummary]> {
        self.conformance_pack_compliance_summary_list.as_deref()
    }
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetConformancePackComplianceSummaryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConformancePackComplianceSummaryOutput");
        formatter.field(
            "conformance_pack_compliance_summary_list",
            &self.conformance_pack_compliance_summary_list,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetConformancePackComplianceSummaryOutput`](crate::output::GetConformancePackComplianceSummaryOutput)
pub mod get_conformance_pack_compliance_summary_output {
    /// A builder for [`GetConformancePackComplianceSummaryOutput`](crate::output::GetConformancePackComplianceSummaryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_compliance_summary_list:
            std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `conformance_pack_compliance_summary_list`.
        ///
        /// To override the contents of this collection use [`set_conformance_pack_compliance_summary_list`](Self::set_conformance_pack_compliance_summary_list).
        ///
        /// <p>A list of <code>ConformancePackComplianceSummary</code> objects. </p>
        pub fn conformance_pack_compliance_summary_list(
            mut self,
            input: crate::model::ConformancePackComplianceSummary,
        ) -> Self {
            let mut v = self
                .conformance_pack_compliance_summary_list
                .unwrap_or_default();
            v.push(input);
            self.conformance_pack_compliance_summary_list = Some(v);
            self
        }
        /// <p>A list of <code>ConformancePackComplianceSummary</code> objects. </p>
        pub fn set_conformance_pack_compliance_summary_list(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ConformancePackComplianceSummary>,
            >,
        ) -> Self {
            self.conformance_pack_compliance_summary_list = input;
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConformancePackComplianceSummaryOutput`](crate::output::GetConformancePackComplianceSummaryOutput)
        pub fn build(self) -> crate::output::GetConformancePackComplianceSummaryOutput {
            crate::output::GetConformancePackComplianceSummaryOutput {
                conformance_pack_compliance_summary_list: self
                    .conformance_pack_compliance_summary_list,
                next_token: self.next_token,
            }
        }
    }
}
impl GetConformancePackComplianceSummaryOutput {
    /// Creates a new builder-style object to manufacture [`GetConformancePackComplianceSummaryOutput`](crate::output::GetConformancePackComplianceSummaryOutput)
    pub fn builder() -> crate::output::get_conformance_pack_compliance_summary_output::Builder {
        crate::output::get_conformance_pack_compliance_summary_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConformancePackComplianceDetailsOutput {
    /// <p>Name of the conformance pack.</p>
    pub conformance_pack_name: std::option::Option<std::string::String>,
    /// <p>Returns a list of <code>ConformancePackEvaluationResult</code> objects.</p>
    pub conformance_pack_rule_evaluation_results:
        std::option::Option<std::vec::Vec<crate::model::ConformancePackEvaluationResult>>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetConformancePackComplianceDetailsOutput {
    /// <p>Name of the conformance pack.</p>
    pub fn conformance_pack_name(&self) -> std::option::Option<&str> {
        self.conformance_pack_name.as_deref()
    }
    /// <p>Returns a list of <code>ConformancePackEvaluationResult</code> objects.</p>
    pub fn conformance_pack_rule_evaluation_results(
        &self,
    ) -> std::option::Option<&[crate::model::ConformancePackEvaluationResult]> {
        self.conformance_pack_rule_evaluation_results.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetConformancePackComplianceDetailsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConformancePackComplianceDetailsOutput");
        formatter.field("conformance_pack_name", &self.conformance_pack_name);
        formatter.field(
            "conformance_pack_rule_evaluation_results",
            &self.conformance_pack_rule_evaluation_results,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetConformancePackComplianceDetailsOutput`](crate::output::GetConformancePackComplianceDetailsOutput)
pub mod get_conformance_pack_compliance_details_output {
    /// A builder for [`GetConformancePackComplianceDetailsOutput`](crate::output::GetConformancePackComplianceDetailsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_name: std::option::Option<std::string::String>,
        pub(crate) conformance_pack_rule_evaluation_results:
            std::option::Option<std::vec::Vec<crate::model::ConformancePackEvaluationResult>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Name of the conformance pack.</p>
        pub fn conformance_pack_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.conformance_pack_name = Some(input.into());
            self
        }
        /// <p>Name of the conformance pack.</p>
        pub fn set_conformance_pack_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.conformance_pack_name = input;
            self
        }
        /// Appends an item to `conformance_pack_rule_evaluation_results`.
        ///
        /// To override the contents of this collection use [`set_conformance_pack_rule_evaluation_results`](Self::set_conformance_pack_rule_evaluation_results).
        ///
        /// <p>Returns a list of <code>ConformancePackEvaluationResult</code> objects.</p>
        pub fn conformance_pack_rule_evaluation_results(
            mut self,
            input: crate::model::ConformancePackEvaluationResult,
        ) -> Self {
            let mut v = self
                .conformance_pack_rule_evaluation_results
                .unwrap_or_default();
            v.push(input);
            self.conformance_pack_rule_evaluation_results = Some(v);
            self
        }
        /// <p>Returns a list of <code>ConformancePackEvaluationResult</code> objects.</p>
        pub fn set_conformance_pack_rule_evaluation_results(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ConformancePackEvaluationResult>,
            >,
        ) -> Self {
            self.conformance_pack_rule_evaluation_results = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConformancePackComplianceDetailsOutput`](crate::output::GetConformancePackComplianceDetailsOutput)
        pub fn build(self) -> crate::output::GetConformancePackComplianceDetailsOutput {
            crate::output::GetConformancePackComplianceDetailsOutput {
                conformance_pack_name: self.conformance_pack_name,
                conformance_pack_rule_evaluation_results: self
                    .conformance_pack_rule_evaluation_results,
                next_token: self.next_token,
            }
        }
    }
}
impl GetConformancePackComplianceDetailsOutput {
    /// Creates a new builder-style object to manufacture [`GetConformancePackComplianceDetailsOutput`](crate::output::GetConformancePackComplianceDetailsOutput)
    pub fn builder() -> crate::output::get_conformance_pack_compliance_details_output::Builder {
        crate::output::get_conformance_pack_compliance_details_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetComplianceSummaryByResourceTypeOutput {
    /// <p>The number of resources that are compliant and the number that are noncompliant. If one or more resource types were provided with the request, the numbers are returned for each resource type. The maximum number returned is 100.</p>
    pub compliance_summaries_by_resource_type:
        std::option::Option<std::vec::Vec<crate::model::ComplianceSummaryByResourceType>>,
}
impl GetComplianceSummaryByResourceTypeOutput {
    /// <p>The number of resources that are compliant and the number that are noncompliant. If one or more resource types were provided with the request, the numbers are returned for each resource type. The maximum number returned is 100.</p>
    pub fn compliance_summaries_by_resource_type(
        &self,
    ) -> std::option::Option<&[crate::model::ComplianceSummaryByResourceType]> {
        self.compliance_summaries_by_resource_type.as_deref()
    }
}
impl std::fmt::Debug for GetComplianceSummaryByResourceTypeOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetComplianceSummaryByResourceTypeOutput");
        formatter.field(
            "compliance_summaries_by_resource_type",
            &self.compliance_summaries_by_resource_type,
        );
        formatter.finish()
    }
}
/// See [`GetComplianceSummaryByResourceTypeOutput`](crate::output::GetComplianceSummaryByResourceTypeOutput)
pub mod get_compliance_summary_by_resource_type_output {
    /// A builder for [`GetComplianceSummaryByResourceTypeOutput`](crate::output::GetComplianceSummaryByResourceTypeOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) compliance_summaries_by_resource_type:
            std::option::Option<std::vec::Vec<crate::model::ComplianceSummaryByResourceType>>,
    }
    impl Builder {
        /// Appends an item to `compliance_summaries_by_resource_type`.
        ///
        /// To override the contents of this collection use [`set_compliance_summaries_by_resource_type`](Self::set_compliance_summaries_by_resource_type).
        ///
        /// <p>The number of resources that are compliant and the number that are noncompliant. If one or more resource types were provided with the request, the numbers are returned for each resource type. The maximum number returned is 100.</p>
        pub fn compliance_summaries_by_resource_type(
            mut self,
            input: crate::model::ComplianceSummaryByResourceType,
        ) -> Self {
            let mut v = self
                .compliance_summaries_by_resource_type
                .unwrap_or_default();
            v.push(input);
            self.compliance_summaries_by_resource_type = Some(v);
            self
        }
        /// <p>The number of resources that are compliant and the number that are noncompliant. If one or more resource types were provided with the request, the numbers are returned for each resource type. The maximum number returned is 100.</p>
        pub fn set_compliance_summaries_by_resource_type(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::ComplianceSummaryByResourceType>,
            >,
        ) -> Self {
            self.compliance_summaries_by_resource_type = input;
            self
        }
        /// Consumes the builder and constructs a [`GetComplianceSummaryByResourceTypeOutput`](crate::output::GetComplianceSummaryByResourceTypeOutput)
        pub fn build(self) -> crate::output::GetComplianceSummaryByResourceTypeOutput {
            crate::output::GetComplianceSummaryByResourceTypeOutput {
                compliance_summaries_by_resource_type: self.compliance_summaries_by_resource_type,
            }
        }
    }
}
impl GetComplianceSummaryByResourceTypeOutput {
    /// Creates a new builder-style object to manufacture [`GetComplianceSummaryByResourceTypeOutput`](crate::output::GetComplianceSummaryByResourceTypeOutput)
    pub fn builder() -> crate::output::get_compliance_summary_by_resource_type_output::Builder {
        crate::output::get_compliance_summary_by_resource_type_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetComplianceSummaryByConfigRuleOutput {
    /// <p>The number of Config rules that are compliant and the number that are noncompliant, up to a maximum of 25 for each.</p>
    pub compliance_summary: std::option::Option<crate::model::ComplianceSummary>,
}
impl GetComplianceSummaryByConfigRuleOutput {
    /// <p>The number of Config rules that are compliant and the number that are noncompliant, up to a maximum of 25 for each.</p>
    pub fn compliance_summary(&self) -> std::option::Option<&crate::model::ComplianceSummary> {
        self.compliance_summary.as_ref()
    }
}
impl std::fmt::Debug for GetComplianceSummaryByConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetComplianceSummaryByConfigRuleOutput");
        formatter.field("compliance_summary", &self.compliance_summary);
        formatter.finish()
    }
}
/// See [`GetComplianceSummaryByConfigRuleOutput`](crate::output::GetComplianceSummaryByConfigRuleOutput)
pub mod get_compliance_summary_by_config_rule_output {
    /// A builder for [`GetComplianceSummaryByConfigRuleOutput`](crate::output::GetComplianceSummaryByConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) compliance_summary: std::option::Option<crate::model::ComplianceSummary>,
    }
    impl Builder {
        /// <p>The number of Config rules that are compliant and the number that are noncompliant, up to a maximum of 25 for each.</p>
        pub fn compliance_summary(mut self, input: crate::model::ComplianceSummary) -> Self {
            self.compliance_summary = Some(input);
            self
        }
        /// <p>The number of Config rules that are compliant and the number that are noncompliant, up to a maximum of 25 for each.</p>
        pub fn set_compliance_summary(
            mut self,
            input: std::option::Option<crate::model::ComplianceSummary>,
        ) -> Self {
            self.compliance_summary = input;
            self
        }
        /// Consumes the builder and constructs a [`GetComplianceSummaryByConfigRuleOutput`](crate::output::GetComplianceSummaryByConfigRuleOutput)
        pub fn build(self) -> crate::output::GetComplianceSummaryByConfigRuleOutput {
            crate::output::GetComplianceSummaryByConfigRuleOutput {
                compliance_summary: self.compliance_summary,
            }
        }
    }
}
impl GetComplianceSummaryByConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`GetComplianceSummaryByConfigRuleOutput`](crate::output::GetComplianceSummaryByConfigRuleOutput)
    pub fn builder() -> crate::output::get_compliance_summary_by_config_rule_output::Builder {
        crate::output::get_compliance_summary_by_config_rule_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetComplianceDetailsByResourceOutput {
    /// <p>Indicates whether the specified Amazon Web Services resource complies each Config rule.</p>
    pub evaluation_results: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetComplianceDetailsByResourceOutput {
    /// <p>Indicates whether the specified Amazon Web Services resource complies each Config rule.</p>
    pub fn evaluation_results(&self) -> std::option::Option<&[crate::model::EvaluationResult]> {
        self.evaluation_results.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetComplianceDetailsByResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetComplianceDetailsByResourceOutput");
        formatter.field("evaluation_results", &self.evaluation_results);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetComplianceDetailsByResourceOutput`](crate::output::GetComplianceDetailsByResourceOutput)
pub mod get_compliance_details_by_resource_output {
    /// A builder for [`GetComplianceDetailsByResourceOutput`](crate::output::GetComplianceDetailsByResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) evaluation_results:
            std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `evaluation_results`.
        ///
        /// To override the contents of this collection use [`set_evaluation_results`](Self::set_evaluation_results).
        ///
        /// <p>Indicates whether the specified Amazon Web Services resource complies each Config rule.</p>
        pub fn evaluation_results(mut self, input: crate::model::EvaluationResult) -> Self {
            let mut v = self.evaluation_results.unwrap_or_default();
            v.push(input);
            self.evaluation_results = Some(v);
            self
        }
        /// <p>Indicates whether the specified Amazon Web Services resource complies each Config rule.</p>
        pub fn set_evaluation_results(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
        ) -> Self {
            self.evaluation_results = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetComplianceDetailsByResourceOutput`](crate::output::GetComplianceDetailsByResourceOutput)
        pub fn build(self) -> crate::output::GetComplianceDetailsByResourceOutput {
            crate::output::GetComplianceDetailsByResourceOutput {
                evaluation_results: self.evaluation_results,
                next_token: self.next_token,
            }
        }
    }
}
impl GetComplianceDetailsByResourceOutput {
    /// Creates a new builder-style object to manufacture [`GetComplianceDetailsByResourceOutput`](crate::output::GetComplianceDetailsByResourceOutput)
    pub fn builder() -> crate::output::get_compliance_details_by_resource_output::Builder {
        crate::output::get_compliance_details_by_resource_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetComplianceDetailsByConfigRuleOutput {
    /// <p>Indicates whether the Amazon Web Services resource complies with the specified Config rule.</p>
    pub evaluation_results: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetComplianceDetailsByConfigRuleOutput {
    /// <p>Indicates whether the Amazon Web Services resource complies with the specified Config rule.</p>
    pub fn evaluation_results(&self) -> std::option::Option<&[crate::model::EvaluationResult]> {
        self.evaluation_results.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetComplianceDetailsByConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetComplianceDetailsByConfigRuleOutput");
        formatter.field("evaluation_results", &self.evaluation_results);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetComplianceDetailsByConfigRuleOutput`](crate::output::GetComplianceDetailsByConfigRuleOutput)
pub mod get_compliance_details_by_config_rule_output {
    /// A builder for [`GetComplianceDetailsByConfigRuleOutput`](crate::output::GetComplianceDetailsByConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) evaluation_results:
            std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `evaluation_results`.
        ///
        /// To override the contents of this collection use [`set_evaluation_results`](Self::set_evaluation_results).
        ///
        /// <p>Indicates whether the Amazon Web Services resource complies with the specified Config rule.</p>
        pub fn evaluation_results(mut self, input: crate::model::EvaluationResult) -> Self {
            let mut v = self.evaluation_results.unwrap_or_default();
            v.push(input);
            self.evaluation_results = Some(v);
            self
        }
        /// <p>Indicates whether the Amazon Web Services resource complies with the specified Config rule.</p>
        pub fn set_evaluation_results(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
        ) -> Self {
            self.evaluation_results = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetComplianceDetailsByConfigRuleOutput`](crate::output::GetComplianceDetailsByConfigRuleOutput)
        pub fn build(self) -> crate::output::GetComplianceDetailsByConfigRuleOutput {
            crate::output::GetComplianceDetailsByConfigRuleOutput {
                evaluation_results: self.evaluation_results,
                next_token: self.next_token,
            }
        }
    }
}
impl GetComplianceDetailsByConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`GetComplianceDetailsByConfigRuleOutput`](crate::output::GetComplianceDetailsByConfigRuleOutput)
    pub fn builder() -> crate::output::get_compliance_details_by_config_rule_output::Builder {
        crate::output::get_compliance_details_by_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAggregateResourceConfigOutput {
    /// <p>Returns a <code>ConfigurationItem</code> object.</p>
    pub configuration_item: std::option::Option<crate::model::ConfigurationItem>,
}
impl GetAggregateResourceConfigOutput {
    /// <p>Returns a <code>ConfigurationItem</code> object.</p>
    pub fn configuration_item(&self) -> std::option::Option<&crate::model::ConfigurationItem> {
        self.configuration_item.as_ref()
    }
}
impl std::fmt::Debug for GetAggregateResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAggregateResourceConfigOutput");
        formatter.field("configuration_item", &self.configuration_item);
        formatter.finish()
    }
}
/// See [`GetAggregateResourceConfigOutput`](crate::output::GetAggregateResourceConfigOutput)
pub mod get_aggregate_resource_config_output {
    /// A builder for [`GetAggregateResourceConfigOutput`](crate::output::GetAggregateResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_item: std::option::Option<crate::model::ConfigurationItem>,
    }
    impl Builder {
        /// <p>Returns a <code>ConfigurationItem</code> object.</p>
        pub fn configuration_item(mut self, input: crate::model::ConfigurationItem) -> Self {
            self.configuration_item = Some(input);
            self
        }
        /// <p>Returns a <code>ConfigurationItem</code> object.</p>
        pub fn set_configuration_item(
            mut self,
            input: std::option::Option<crate::model::ConfigurationItem>,
        ) -> Self {
            self.configuration_item = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAggregateResourceConfigOutput`](crate::output::GetAggregateResourceConfigOutput)
        pub fn build(self) -> crate::output::GetAggregateResourceConfigOutput {
            crate::output::GetAggregateResourceConfigOutput {
                configuration_item: self.configuration_item,
            }
        }
    }
}
impl GetAggregateResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`GetAggregateResourceConfigOutput`](crate::output::GetAggregateResourceConfigOutput)
    pub fn builder() -> crate::output::get_aggregate_resource_config_output::Builder {
        crate::output::get_aggregate_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAggregateDiscoveredResourceCountsOutput {
    /// <p>The total number of resources that are present in an aggregator with the filters that you provide.</p>
    pub total_discovered_resources: i64,
    /// <p>The key passed into the request object. If <code>GroupByKey</code> is not provided, the result will be empty.</p>
    pub group_by_key: std::option::Option<std::string::String>,
    /// <p>Returns a list of GroupedResourceCount objects.</p>
    pub grouped_resource_counts:
        std::option::Option<std::vec::Vec<crate::model::GroupedResourceCount>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateDiscoveredResourceCountsOutput {
    /// <p>The total number of resources that are present in an aggregator with the filters that you provide.</p>
    pub fn total_discovered_resources(&self) -> i64 {
        self.total_discovered_resources
    }
    /// <p>The key passed into the request object. If <code>GroupByKey</code> is not provided, the result will be empty.</p>
    pub fn group_by_key(&self) -> std::option::Option<&str> {
        self.group_by_key.as_deref()
    }
    /// <p>Returns a list of GroupedResourceCount objects.</p>
    pub fn grouped_resource_counts(
        &self,
    ) -> std::option::Option<&[crate::model::GroupedResourceCount]> {
        self.grouped_resource_counts.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetAggregateDiscoveredResourceCountsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAggregateDiscoveredResourceCountsOutput");
        formatter.field(
            "total_discovered_resources",
            &self.total_discovered_resources,
        );
        formatter.field("group_by_key", &self.group_by_key);
        formatter.field("grouped_resource_counts", &self.grouped_resource_counts);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetAggregateDiscoveredResourceCountsOutput`](crate::output::GetAggregateDiscoveredResourceCountsOutput)
pub mod get_aggregate_discovered_resource_counts_output {
    /// A builder for [`GetAggregateDiscoveredResourceCountsOutput`](crate::output::GetAggregateDiscoveredResourceCountsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) total_discovered_resources: std::option::Option<i64>,
        pub(crate) group_by_key: std::option::Option<std::string::String>,
        pub(crate) grouped_resource_counts:
            std::option::Option<std::vec::Vec<crate::model::GroupedResourceCount>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The total number of resources that are present in an aggregator with the filters that you provide.</p>
        pub fn total_discovered_resources(mut self, input: i64) -> Self {
            self.total_discovered_resources = Some(input);
            self
        }
        /// <p>The total number of resources that are present in an aggregator with the filters that you provide.</p>
        pub fn set_total_discovered_resources(mut self, input: std::option::Option<i64>) -> Self {
            self.total_discovered_resources = input;
            self
        }
        /// <p>The key passed into the request object. If <code>GroupByKey</code> is not provided, the result will be empty.</p>
        pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
            self.group_by_key = Some(input.into());
            self
        }
        /// <p>The key passed into the request object. If <code>GroupByKey</code> is not provided, the result will be empty.</p>
        pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.group_by_key = input;
            self
        }
        /// Appends an item to `grouped_resource_counts`.
        ///
        /// To override the contents of this collection use [`set_grouped_resource_counts`](Self::set_grouped_resource_counts).
        ///
        /// <p>Returns a list of GroupedResourceCount objects.</p>
        pub fn grouped_resource_counts(
            mut self,
            input: crate::model::GroupedResourceCount,
        ) -> Self {
            let mut v = self.grouped_resource_counts.unwrap_or_default();
            v.push(input);
            self.grouped_resource_counts = Some(v);
            self
        }
        /// <p>Returns a list of GroupedResourceCount objects.</p>
        pub fn set_grouped_resource_counts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::GroupedResourceCount>>,
        ) -> Self {
            self.grouped_resource_counts = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAggregateDiscoveredResourceCountsOutput`](crate::output::GetAggregateDiscoveredResourceCountsOutput)
        pub fn build(self) -> crate::output::GetAggregateDiscoveredResourceCountsOutput {
            crate::output::GetAggregateDiscoveredResourceCountsOutput {
                total_discovered_resources: self.total_discovered_resources.unwrap_or_default(),
                group_by_key: self.group_by_key,
                grouped_resource_counts: self.grouped_resource_counts,
                next_token: self.next_token,
            }
        }
    }
}
impl GetAggregateDiscoveredResourceCountsOutput {
    /// Creates a new builder-style object to manufacture [`GetAggregateDiscoveredResourceCountsOutput`](crate::output::GetAggregateDiscoveredResourceCountsOutput)
    pub fn builder() -> crate::output::get_aggregate_discovered_resource_counts_output::Builder {
        crate::output::get_aggregate_discovered_resource_counts_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAggregateConformancePackComplianceSummaryOutput {
    /// <p>Returns a list of <code>AggregateConformancePackComplianceSummary</code> object.</p>
    pub aggregate_conformance_pack_compliance_summaries:
        std::option::Option<std::vec::Vec<crate::model::AggregateConformancePackComplianceSummary>>,
    /// <p>Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.</p>
    pub group_by_key: std::option::Option<std::string::String>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateConformancePackComplianceSummaryOutput {
    /// <p>Returns a list of <code>AggregateConformancePackComplianceSummary</code> object.</p>
    pub fn aggregate_conformance_pack_compliance_summaries(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateConformancePackComplianceSummary]> {
        self.aggregate_conformance_pack_compliance_summaries
            .as_deref()
    }
    /// <p>Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.</p>
    pub fn group_by_key(&self) -> std::option::Option<&str> {
        self.group_by_key.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetAggregateConformancePackComplianceSummaryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAggregateConformancePackComplianceSummaryOutput");
        formatter.field(
            "aggregate_conformance_pack_compliance_summaries",
            &self.aggregate_conformance_pack_compliance_summaries,
        );
        formatter.field("group_by_key", &self.group_by_key);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetAggregateConformancePackComplianceSummaryOutput`](crate::output::GetAggregateConformancePackComplianceSummaryOutput)
pub mod get_aggregate_conformance_pack_compliance_summary_output {
    /// A builder for [`GetAggregateConformancePackComplianceSummaryOutput`](crate::output::GetAggregateConformancePackComplianceSummaryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregate_conformance_pack_compliance_summaries: std::option::Option<
            std::vec::Vec<crate::model::AggregateConformancePackComplianceSummary>,
        >,
        pub(crate) group_by_key: std::option::Option<std::string::String>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregate_conformance_pack_compliance_summaries`.
        ///
        /// To override the contents of this collection use [`set_aggregate_conformance_pack_compliance_summaries`](Self::set_aggregate_conformance_pack_compliance_summaries).
        ///
        /// <p>Returns a list of <code>AggregateConformancePackComplianceSummary</code> object.</p>
        pub fn aggregate_conformance_pack_compliance_summaries(
            mut self,
            input: crate::model::AggregateConformancePackComplianceSummary,
        ) -> Self {
            let mut v = self
                .aggregate_conformance_pack_compliance_summaries
                .unwrap_or_default();
            v.push(input);
            self.aggregate_conformance_pack_compliance_summaries = Some(v);
            self
        }
        /// <p>Returns a list of <code>AggregateConformancePackComplianceSummary</code> object.</p>
        pub fn set_aggregate_conformance_pack_compliance_summaries(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::AggregateConformancePackComplianceSummary>,
            >,
        ) -> Self {
            self.aggregate_conformance_pack_compliance_summaries = input;
            self
        }
        /// <p>Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.</p>
        pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
            self.group_by_key = Some(input.into());
            self
        }
        /// <p>Groups the result based on Amazon Web Services account ID or Amazon Web Services Region.</p>
        pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.group_by_key = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAggregateConformancePackComplianceSummaryOutput`](crate::output::GetAggregateConformancePackComplianceSummaryOutput)
        pub fn build(self) -> crate::output::GetAggregateConformancePackComplianceSummaryOutput {
            crate::output::GetAggregateConformancePackComplianceSummaryOutput {
                aggregate_conformance_pack_compliance_summaries: self
                    .aggregate_conformance_pack_compliance_summaries,
                group_by_key: self.group_by_key,
                next_token: self.next_token,
            }
        }
    }
}
impl GetAggregateConformancePackComplianceSummaryOutput {
    /// Creates a new builder-style object to manufacture [`GetAggregateConformancePackComplianceSummaryOutput`](crate::output::GetAggregateConformancePackComplianceSummaryOutput)
    pub fn builder(
    ) -> crate::output::get_aggregate_conformance_pack_compliance_summary_output::Builder {
        crate::output::get_aggregate_conformance_pack_compliance_summary_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAggregateConfigRuleComplianceSummaryOutput {
    /// <p>Groups the result based on ACCOUNT_ID or AWS_REGION.</p>
    pub group_by_key: std::option::Option<std::string::String>,
    /// <p>Returns a list of AggregateComplianceCounts object.</p>
    pub aggregate_compliance_counts:
        std::option::Option<std::vec::Vec<crate::model::AggregateComplianceCount>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateConfigRuleComplianceSummaryOutput {
    /// <p>Groups the result based on ACCOUNT_ID or AWS_REGION.</p>
    pub fn group_by_key(&self) -> std::option::Option<&str> {
        self.group_by_key.as_deref()
    }
    /// <p>Returns a list of AggregateComplianceCounts object.</p>
    pub fn aggregate_compliance_counts(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateComplianceCount]> {
        self.aggregate_compliance_counts.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetAggregateConfigRuleComplianceSummaryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAggregateConfigRuleComplianceSummaryOutput");
        formatter.field("group_by_key", &self.group_by_key);
        formatter.field(
            "aggregate_compliance_counts",
            &self.aggregate_compliance_counts,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetAggregateConfigRuleComplianceSummaryOutput`](crate::output::GetAggregateConfigRuleComplianceSummaryOutput)
pub mod get_aggregate_config_rule_compliance_summary_output {
    /// A builder for [`GetAggregateConfigRuleComplianceSummaryOutput`](crate::output::GetAggregateConfigRuleComplianceSummaryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) group_by_key: std::option::Option<std::string::String>,
        pub(crate) aggregate_compliance_counts:
            std::option::Option<std::vec::Vec<crate::model::AggregateComplianceCount>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Groups the result based on ACCOUNT_ID or AWS_REGION.</p>
        pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
            self.group_by_key = Some(input.into());
            self
        }
        /// <p>Groups the result based on ACCOUNT_ID or AWS_REGION.</p>
        pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.group_by_key = input;
            self
        }
        /// Appends an item to `aggregate_compliance_counts`.
        ///
        /// To override the contents of this collection use [`set_aggregate_compliance_counts`](Self::set_aggregate_compliance_counts).
        ///
        /// <p>Returns a list of AggregateComplianceCounts object.</p>
        pub fn aggregate_compliance_counts(
            mut self,
            input: crate::model::AggregateComplianceCount,
        ) -> Self {
            let mut v = self.aggregate_compliance_counts.unwrap_or_default();
            v.push(input);
            self.aggregate_compliance_counts = Some(v);
            self
        }
        /// <p>Returns a list of AggregateComplianceCounts object.</p>
        pub fn set_aggregate_compliance_counts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregateComplianceCount>>,
        ) -> Self {
            self.aggregate_compliance_counts = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAggregateConfigRuleComplianceSummaryOutput`](crate::output::GetAggregateConfigRuleComplianceSummaryOutput)
        pub fn build(self) -> crate::output::GetAggregateConfigRuleComplianceSummaryOutput {
            crate::output::GetAggregateConfigRuleComplianceSummaryOutput {
                group_by_key: self.group_by_key,
                aggregate_compliance_counts: self.aggregate_compliance_counts,
                next_token: self.next_token,
            }
        }
    }
}
impl GetAggregateConfigRuleComplianceSummaryOutput {
    /// Creates a new builder-style object to manufacture [`GetAggregateConfigRuleComplianceSummaryOutput`](crate::output::GetAggregateConfigRuleComplianceSummaryOutput)
    pub fn builder() -> crate::output::get_aggregate_config_rule_compliance_summary_output::Builder
    {
        crate::output::get_aggregate_config_rule_compliance_summary_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAggregateComplianceDetailsByConfigRuleOutput {
    /// <p>Returns an AggregateEvaluationResults object.</p>
    pub aggregate_evaluation_results:
        std::option::Option<std::vec::Vec<crate::model::AggregateEvaluationResult>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateComplianceDetailsByConfigRuleOutput {
    /// <p>Returns an AggregateEvaluationResults object.</p>
    pub fn aggregate_evaluation_results(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateEvaluationResult]> {
        self.aggregate_evaluation_results.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetAggregateComplianceDetailsByConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAggregateComplianceDetailsByConfigRuleOutput");
        formatter.field(
            "aggregate_evaluation_results",
            &self.aggregate_evaluation_results,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetAggregateComplianceDetailsByConfigRuleOutput`](crate::output::GetAggregateComplianceDetailsByConfigRuleOutput)
pub mod get_aggregate_compliance_details_by_config_rule_output {
    /// A builder for [`GetAggregateComplianceDetailsByConfigRuleOutput`](crate::output::GetAggregateComplianceDetailsByConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregate_evaluation_results:
            std::option::Option<std::vec::Vec<crate::model::AggregateEvaluationResult>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregate_evaluation_results`.
        ///
        /// To override the contents of this collection use [`set_aggregate_evaluation_results`](Self::set_aggregate_evaluation_results).
        ///
        /// <p>Returns an AggregateEvaluationResults object.</p>
        pub fn aggregate_evaluation_results(
            mut self,
            input: crate::model::AggregateEvaluationResult,
        ) -> Self {
            let mut v = self.aggregate_evaluation_results.unwrap_or_default();
            v.push(input);
            self.aggregate_evaluation_results = Some(v);
            self
        }
        /// <p>Returns an AggregateEvaluationResults object.</p>
        pub fn set_aggregate_evaluation_results(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregateEvaluationResult>>,
        ) -> Self {
            self.aggregate_evaluation_results = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAggregateComplianceDetailsByConfigRuleOutput`](crate::output::GetAggregateComplianceDetailsByConfigRuleOutput)
        pub fn build(self) -> crate::output::GetAggregateComplianceDetailsByConfigRuleOutput {
            crate::output::GetAggregateComplianceDetailsByConfigRuleOutput {
                aggregate_evaluation_results: self.aggregate_evaluation_results,
                next_token: self.next_token,
            }
        }
    }
}
impl GetAggregateComplianceDetailsByConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`GetAggregateComplianceDetailsByConfigRuleOutput`](crate::output::GetAggregateComplianceDetailsByConfigRuleOutput)
    pub fn builder(
    ) -> crate::output::get_aggregate_compliance_details_by_config_rule_output::Builder {
        crate::output::get_aggregate_compliance_details_by_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRetentionConfigurationsOutput {
    /// <p>Returns a retention configuration object.</p>
    pub retention_configurations:
        std::option::Option<std::vec::Vec<crate::model::RetentionConfiguration>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRetentionConfigurationsOutput {
    /// <p>Returns a retention configuration object.</p>
    pub fn retention_configurations(
        &self,
    ) -> std::option::Option<&[crate::model::RetentionConfiguration]> {
        self.retention_configurations.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeRetentionConfigurationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRetentionConfigurationsOutput");
        formatter.field("retention_configurations", &self.retention_configurations);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeRetentionConfigurationsOutput`](crate::output::DescribeRetentionConfigurationsOutput)
pub mod describe_retention_configurations_output {
    /// A builder for [`DescribeRetentionConfigurationsOutput`](crate::output::DescribeRetentionConfigurationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) retention_configurations:
            std::option::Option<std::vec::Vec<crate::model::RetentionConfiguration>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `retention_configurations`.
        ///
        /// To override the contents of this collection use [`set_retention_configurations`](Self::set_retention_configurations).
        ///
        /// <p>Returns a retention configuration object.</p>
        pub fn retention_configurations(
            mut self,
            input: crate::model::RetentionConfiguration,
        ) -> Self {
            let mut v = self.retention_configurations.unwrap_or_default();
            v.push(input);
            self.retention_configurations = Some(v);
            self
        }
        /// <p>Returns a retention configuration object.</p>
        pub fn set_retention_configurations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RetentionConfiguration>>,
        ) -> Self {
            self.retention_configurations = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRetentionConfigurationsOutput`](crate::output::DescribeRetentionConfigurationsOutput)
        pub fn build(self) -> crate::output::DescribeRetentionConfigurationsOutput {
            crate::output::DescribeRetentionConfigurationsOutput {
                retention_configurations: self.retention_configurations,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeRetentionConfigurationsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRetentionConfigurationsOutput`](crate::output::DescribeRetentionConfigurationsOutput)
    pub fn builder() -> crate::output::describe_retention_configurations_output::Builder {
        crate::output::describe_retention_configurations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRemediationExecutionStatusOutput {
    /// <p>Returns a list of remediation execution statuses objects.</p>
    pub remediation_execution_statuses:
        std::option::Option<std::vec::Vec<crate::model::RemediationExecutionStatus>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRemediationExecutionStatusOutput {
    /// <p>Returns a list of remediation execution statuses objects.</p>
    pub fn remediation_execution_statuses(
        &self,
    ) -> std::option::Option<&[crate::model::RemediationExecutionStatus]> {
        self.remediation_execution_statuses.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeRemediationExecutionStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRemediationExecutionStatusOutput");
        formatter.field(
            "remediation_execution_statuses",
            &self.remediation_execution_statuses,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeRemediationExecutionStatusOutput`](crate::output::DescribeRemediationExecutionStatusOutput)
pub mod describe_remediation_execution_status_output {
    /// A builder for [`DescribeRemediationExecutionStatusOutput`](crate::output::DescribeRemediationExecutionStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) remediation_execution_statuses:
            std::option::Option<std::vec::Vec<crate::model::RemediationExecutionStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `remediation_execution_statuses`.
        ///
        /// To override the contents of this collection use [`set_remediation_execution_statuses`](Self::set_remediation_execution_statuses).
        ///
        /// <p>Returns a list of remediation execution statuses objects.</p>
        pub fn remediation_execution_statuses(
            mut self,
            input: crate::model::RemediationExecutionStatus,
        ) -> Self {
            let mut v = self.remediation_execution_statuses.unwrap_or_default();
            v.push(input);
            self.remediation_execution_statuses = Some(v);
            self
        }
        /// <p>Returns a list of remediation execution statuses objects.</p>
        pub fn set_remediation_execution_statuses(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RemediationExecutionStatus>>,
        ) -> Self {
            self.remediation_execution_statuses = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRemediationExecutionStatusOutput`](crate::output::DescribeRemediationExecutionStatusOutput)
        pub fn build(self) -> crate::output::DescribeRemediationExecutionStatusOutput {
            crate::output::DescribeRemediationExecutionStatusOutput {
                remediation_execution_statuses: self.remediation_execution_statuses,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeRemediationExecutionStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRemediationExecutionStatusOutput`](crate::output::DescribeRemediationExecutionStatusOutput)
    pub fn builder() -> crate::output::describe_remediation_execution_status_output::Builder {
        crate::output::describe_remediation_execution_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRemediationExceptionsOutput {
    /// <p>Returns a list of remediation exception objects.</p>
    pub remediation_exceptions:
        std::option::Option<std::vec::Vec<crate::model::RemediationException>>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRemediationExceptionsOutput {
    /// <p>Returns a list of remediation exception objects.</p>
    pub fn remediation_exceptions(
        &self,
    ) -> std::option::Option<&[crate::model::RemediationException]> {
        self.remediation_exceptions.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeRemediationExceptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRemediationExceptionsOutput");
        formatter.field("remediation_exceptions", &self.remediation_exceptions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeRemediationExceptionsOutput`](crate::output::DescribeRemediationExceptionsOutput)
pub mod describe_remediation_exceptions_output {
    /// A builder for [`DescribeRemediationExceptionsOutput`](crate::output::DescribeRemediationExceptionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) remediation_exceptions:
            std::option::Option<std::vec::Vec<crate::model::RemediationException>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `remediation_exceptions`.
        ///
        /// To override the contents of this collection use [`set_remediation_exceptions`](Self::set_remediation_exceptions).
        ///
        /// <p>Returns a list of remediation exception objects.</p>
        pub fn remediation_exceptions(mut self, input: crate::model::RemediationException) -> Self {
            let mut v = self.remediation_exceptions.unwrap_or_default();
            v.push(input);
            self.remediation_exceptions = Some(v);
            self
        }
        /// <p>Returns a list of remediation exception objects.</p>
        pub fn set_remediation_exceptions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RemediationException>>,
        ) -> Self {
            self.remediation_exceptions = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRemediationExceptionsOutput`](crate::output::DescribeRemediationExceptionsOutput)
        pub fn build(self) -> crate::output::DescribeRemediationExceptionsOutput {
            crate::output::DescribeRemediationExceptionsOutput {
                remediation_exceptions: self.remediation_exceptions,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeRemediationExceptionsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRemediationExceptionsOutput`](crate::output::DescribeRemediationExceptionsOutput)
    pub fn builder() -> crate::output::describe_remediation_exceptions_output::Builder {
        crate::output::describe_remediation_exceptions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeRemediationConfigurationsOutput {
    /// <p>Returns a remediation configuration object.</p>
    pub remediation_configurations:
        std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
}
impl DescribeRemediationConfigurationsOutput {
    /// <p>Returns a remediation configuration object.</p>
    pub fn remediation_configurations(
        &self,
    ) -> std::option::Option<&[crate::model::RemediationConfiguration]> {
        self.remediation_configurations.as_deref()
    }
}
impl std::fmt::Debug for DescribeRemediationConfigurationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeRemediationConfigurationsOutput");
        formatter.field(
            "remediation_configurations",
            &self.remediation_configurations,
        );
        formatter.finish()
    }
}
/// See [`DescribeRemediationConfigurationsOutput`](crate::output::DescribeRemediationConfigurationsOutput)
pub mod describe_remediation_configurations_output {
    /// A builder for [`DescribeRemediationConfigurationsOutput`](crate::output::DescribeRemediationConfigurationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) remediation_configurations:
            std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
    }
    impl Builder {
        /// Appends an item to `remediation_configurations`.
        ///
        /// To override the contents of this collection use [`set_remediation_configurations`](Self::set_remediation_configurations).
        ///
        /// <p>Returns a remediation configuration object.</p>
        pub fn remediation_configurations(
            mut self,
            input: crate::model::RemediationConfiguration,
        ) -> Self {
            let mut v = self.remediation_configurations.unwrap_or_default();
            v.push(input);
            self.remediation_configurations = Some(v);
            self
        }
        /// <p>Returns a remediation configuration object.</p>
        pub fn set_remediation_configurations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
        ) -> Self {
            self.remediation_configurations = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeRemediationConfigurationsOutput`](crate::output::DescribeRemediationConfigurationsOutput)
        pub fn build(self) -> crate::output::DescribeRemediationConfigurationsOutput {
            crate::output::DescribeRemediationConfigurationsOutput {
                remediation_configurations: self.remediation_configurations,
            }
        }
    }
}
impl DescribeRemediationConfigurationsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeRemediationConfigurationsOutput`](crate::output::DescribeRemediationConfigurationsOutput)
    pub fn builder() -> crate::output::describe_remediation_configurations_output::Builder {
        crate::output::describe_remediation_configurations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribePendingAggregationRequestsOutput {
    /// <p>Returns a PendingAggregationRequests object.</p>
    pub pending_aggregation_requests:
        std::option::Option<std::vec::Vec<crate::model::PendingAggregationRequest>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribePendingAggregationRequestsOutput {
    /// <p>Returns a PendingAggregationRequests object.</p>
    pub fn pending_aggregation_requests(
        &self,
    ) -> std::option::Option<&[crate::model::PendingAggregationRequest]> {
        self.pending_aggregation_requests.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribePendingAggregationRequestsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribePendingAggregationRequestsOutput");
        formatter.field(
            "pending_aggregation_requests",
            &self.pending_aggregation_requests,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribePendingAggregationRequestsOutput`](crate::output::DescribePendingAggregationRequestsOutput)
pub mod describe_pending_aggregation_requests_output {
    /// A builder for [`DescribePendingAggregationRequestsOutput`](crate::output::DescribePendingAggregationRequestsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) pending_aggregation_requests:
            std::option::Option<std::vec::Vec<crate::model::PendingAggregationRequest>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `pending_aggregation_requests`.
        ///
        /// To override the contents of this collection use [`set_pending_aggregation_requests`](Self::set_pending_aggregation_requests).
        ///
        /// <p>Returns a PendingAggregationRequests object.</p>
        pub fn pending_aggregation_requests(
            mut self,
            input: crate::model::PendingAggregationRequest,
        ) -> Self {
            let mut v = self.pending_aggregation_requests.unwrap_or_default();
            v.push(input);
            self.pending_aggregation_requests = Some(v);
            self
        }
        /// <p>Returns a PendingAggregationRequests object.</p>
        pub fn set_pending_aggregation_requests(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::PendingAggregationRequest>>,
        ) -> Self {
            self.pending_aggregation_requests = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribePendingAggregationRequestsOutput`](crate::output::DescribePendingAggregationRequestsOutput)
        pub fn build(self) -> crate::output::DescribePendingAggregationRequestsOutput {
            crate::output::DescribePendingAggregationRequestsOutput {
                pending_aggregation_requests: self.pending_aggregation_requests,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribePendingAggregationRequestsOutput {
    /// Creates a new builder-style object to manufacture [`DescribePendingAggregationRequestsOutput`](crate::output::DescribePendingAggregationRequestsOutput)
    pub fn builder() -> crate::output::describe_pending_aggregation_requests_output::Builder {
        crate::output::describe_pending_aggregation_requests_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOrganizationConformancePackStatusesOutput {
    /// <p>A list of <code>OrganizationConformancePackStatus</code> objects. </p>
    pub organization_conformance_pack_statuses:
        std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePackStatus>>,
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConformancePackStatusesOutput {
    /// <p>A list of <code>OrganizationConformancePackStatus</code> objects. </p>
    pub fn organization_conformance_pack_statuses(
        &self,
    ) -> std::option::Option<&[crate::model::OrganizationConformancePackStatus]> {
        self.organization_conformance_pack_statuses.as_deref()
    }
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeOrganizationConformancePackStatusesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOrganizationConformancePackStatusesOutput");
        formatter.field(
            "organization_conformance_pack_statuses",
            &self.organization_conformance_pack_statuses,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeOrganizationConformancePackStatusesOutput`](crate::output::DescribeOrganizationConformancePackStatusesOutput)
pub mod describe_organization_conformance_pack_statuses_output {
    /// A builder for [`DescribeOrganizationConformancePackStatusesOutput`](crate::output::DescribeOrganizationConformancePackStatusesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_conformance_pack_statuses:
            std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePackStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_conformance_pack_statuses`.
        ///
        /// To override the contents of this collection use [`set_organization_conformance_pack_statuses`](Self::set_organization_conformance_pack_statuses).
        ///
        /// <p>A list of <code>OrganizationConformancePackStatus</code> objects. </p>
        pub fn organization_conformance_pack_statuses(
            mut self,
            input: crate::model::OrganizationConformancePackStatus,
        ) -> Self {
            let mut v = self
                .organization_conformance_pack_statuses
                .unwrap_or_default();
            v.push(input);
            self.organization_conformance_pack_statuses = Some(v);
            self
        }
        /// <p>A list of <code>OrganizationConformancePackStatus</code> objects. </p>
        pub fn set_organization_conformance_pack_statuses(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::OrganizationConformancePackStatus>,
            >,
        ) -> Self {
            self.organization_conformance_pack_statuses = input;
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOrganizationConformancePackStatusesOutput`](crate::output::DescribeOrganizationConformancePackStatusesOutput)
        pub fn build(self) -> crate::output::DescribeOrganizationConformancePackStatusesOutput {
            crate::output::DescribeOrganizationConformancePackStatusesOutput {
                organization_conformance_pack_statuses: self.organization_conformance_pack_statuses,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeOrganizationConformancePackStatusesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOrganizationConformancePackStatusesOutput`](crate::output::DescribeOrganizationConformancePackStatusesOutput)
    pub fn builder(
    ) -> crate::output::describe_organization_conformance_pack_statuses_output::Builder {
        crate::output::describe_organization_conformance_pack_statuses_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOrganizationConformancePacksOutput {
    /// <p>Returns a list of OrganizationConformancePacks objects.</p>
    pub organization_conformance_packs:
        std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePack>>,
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConformancePacksOutput {
    /// <p>Returns a list of OrganizationConformancePacks objects.</p>
    pub fn organization_conformance_packs(
        &self,
    ) -> std::option::Option<&[crate::model::OrganizationConformancePack]> {
        self.organization_conformance_packs.as_deref()
    }
    /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeOrganizationConformancePacksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOrganizationConformancePacksOutput");
        formatter.field(
            "organization_conformance_packs",
            &self.organization_conformance_packs,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeOrganizationConformancePacksOutput`](crate::output::DescribeOrganizationConformancePacksOutput)
pub mod describe_organization_conformance_packs_output {
    /// A builder for [`DescribeOrganizationConformancePacksOutput`](crate::output::DescribeOrganizationConformancePacksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_conformance_packs:
            std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePack>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_conformance_packs`.
        ///
        /// To override the contents of this collection use [`set_organization_conformance_packs`](Self::set_organization_conformance_packs).
        ///
        /// <p>Returns a list of OrganizationConformancePacks objects.</p>
        pub fn organization_conformance_packs(
            mut self,
            input: crate::model::OrganizationConformancePack,
        ) -> Self {
            let mut v = self.organization_conformance_packs.unwrap_or_default();
            v.push(input);
            self.organization_conformance_packs = Some(v);
            self
        }
        /// <p>Returns a list of OrganizationConformancePacks objects.</p>
        pub fn set_organization_conformance_packs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePack>>,
        ) -> Self {
            self.organization_conformance_packs = input;
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The nextToken string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOrganizationConformancePacksOutput`](crate::output::DescribeOrganizationConformancePacksOutput)
        pub fn build(self) -> crate::output::DescribeOrganizationConformancePacksOutput {
            crate::output::DescribeOrganizationConformancePacksOutput {
                organization_conformance_packs: self.organization_conformance_packs,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeOrganizationConformancePacksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOrganizationConformancePacksOutput`](crate::output::DescribeOrganizationConformancePacksOutput)
    pub fn builder() -> crate::output::describe_organization_conformance_packs_output::Builder {
        crate::output::describe_organization_conformance_packs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOrganizationConfigRuleStatusesOutput {
    /// <p>A list of <code>OrganizationConfigRuleStatus</code> objects.</p>
    pub organization_config_rule_statuses:
        std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRuleStatus>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConfigRuleStatusesOutput {
    /// <p>A list of <code>OrganizationConfigRuleStatus</code> objects.</p>
    pub fn organization_config_rule_statuses(
        &self,
    ) -> std::option::Option<&[crate::model::OrganizationConfigRuleStatus]> {
        self.organization_config_rule_statuses.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeOrganizationConfigRuleStatusesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOrganizationConfigRuleStatusesOutput");
        formatter.field(
            "organization_config_rule_statuses",
            &self.organization_config_rule_statuses,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeOrganizationConfigRuleStatusesOutput`](crate::output::DescribeOrganizationConfigRuleStatusesOutput)
pub mod describe_organization_config_rule_statuses_output {
    /// A builder for [`DescribeOrganizationConfigRuleStatusesOutput`](crate::output::DescribeOrganizationConfigRuleStatusesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_config_rule_statuses:
            std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRuleStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_config_rule_statuses`.
        ///
        /// To override the contents of this collection use [`set_organization_config_rule_statuses`](Self::set_organization_config_rule_statuses).
        ///
        /// <p>A list of <code>OrganizationConfigRuleStatus</code> objects.</p>
        pub fn organization_config_rule_statuses(
            mut self,
            input: crate::model::OrganizationConfigRuleStatus,
        ) -> Self {
            let mut v = self.organization_config_rule_statuses.unwrap_or_default();
            v.push(input);
            self.organization_config_rule_statuses = Some(v);
            self
        }
        /// <p>A list of <code>OrganizationConfigRuleStatus</code> objects.</p>
        pub fn set_organization_config_rule_statuses(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRuleStatus>>,
        ) -> Self {
            self.organization_config_rule_statuses = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOrganizationConfigRuleStatusesOutput`](crate::output::DescribeOrganizationConfigRuleStatusesOutput)
        pub fn build(self) -> crate::output::DescribeOrganizationConfigRuleStatusesOutput {
            crate::output::DescribeOrganizationConfigRuleStatusesOutput {
                organization_config_rule_statuses: self.organization_config_rule_statuses,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeOrganizationConfigRuleStatusesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOrganizationConfigRuleStatusesOutput`](crate::output::DescribeOrganizationConfigRuleStatusesOutput)
    pub fn builder() -> crate::output::describe_organization_config_rule_statuses_output::Builder {
        crate::output::describe_organization_config_rule_statuses_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOrganizationConfigRulesOutput {
    /// <p>Returns a list of <code>OrganizationConfigRule</code> objects.</p>
    pub organization_config_rules:
        std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRule>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConfigRulesOutput {
    /// <p>Returns a list of <code>OrganizationConfigRule</code> objects.</p>
    pub fn organization_config_rules(
        &self,
    ) -> std::option::Option<&[crate::model::OrganizationConfigRule]> {
        self.organization_config_rules.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeOrganizationConfigRulesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOrganizationConfigRulesOutput");
        formatter.field("organization_config_rules", &self.organization_config_rules);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeOrganizationConfigRulesOutput`](crate::output::DescribeOrganizationConfigRulesOutput)
pub mod describe_organization_config_rules_output {
    /// A builder for [`DescribeOrganizationConfigRulesOutput`](crate::output::DescribeOrganizationConfigRulesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) organization_config_rules:
            std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRule>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `organization_config_rules`.
        ///
        /// To override the contents of this collection use [`set_organization_config_rules`](Self::set_organization_config_rules).
        ///
        /// <p>Returns a list of <code>OrganizationConfigRule</code> objects.</p>
        pub fn organization_config_rules(
            mut self,
            input: crate::model::OrganizationConfigRule,
        ) -> Self {
            let mut v = self.organization_config_rules.unwrap_or_default();
            v.push(input);
            self.organization_config_rules = Some(v);
            self
        }
        /// <p>Returns a list of <code>OrganizationConfigRule</code> objects.</p>
        pub fn set_organization_config_rules(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRule>>,
        ) -> Self {
            self.organization_config_rules = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response. </p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOrganizationConfigRulesOutput`](crate::output::DescribeOrganizationConfigRulesOutput)
        pub fn build(self) -> crate::output::DescribeOrganizationConfigRulesOutput {
            crate::output::DescribeOrganizationConfigRulesOutput {
                organization_config_rules: self.organization_config_rules,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeOrganizationConfigRulesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOrganizationConfigRulesOutput`](crate::output::DescribeOrganizationConfigRulesOutput)
    pub fn builder() -> crate::output::describe_organization_config_rules_output::Builder {
        crate::output::describe_organization_config_rules_output::Builder::default()
    }
}

/// <p>The output for the <code>DescribeDeliveryChannelStatus</code> action.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDeliveryChannelStatusOutput {
    /// <p>A list that contains the status of a specified delivery channel.</p>
    pub delivery_channels_status:
        std::option::Option<std::vec::Vec<crate::model::DeliveryChannelStatus>>,
}
impl DescribeDeliveryChannelStatusOutput {
    /// <p>A list that contains the status of a specified delivery channel.</p>
    pub fn delivery_channels_status(
        &self,
    ) -> std::option::Option<&[crate::model::DeliveryChannelStatus]> {
        self.delivery_channels_status.as_deref()
    }
}
impl std::fmt::Debug for DescribeDeliveryChannelStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDeliveryChannelStatusOutput");
        formatter.field("delivery_channels_status", &self.delivery_channels_status);
        formatter.finish()
    }
}
/// See [`DescribeDeliveryChannelStatusOutput`](crate::output::DescribeDeliveryChannelStatusOutput)
pub mod describe_delivery_channel_status_output {
    /// A builder for [`DescribeDeliveryChannelStatusOutput`](crate::output::DescribeDeliveryChannelStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) delivery_channels_status:
            std::option::Option<std::vec::Vec<crate::model::DeliveryChannelStatus>>,
    }
    impl Builder {
        /// Appends an item to `delivery_channels_status`.
        ///
        /// To override the contents of this collection use [`set_delivery_channels_status`](Self::set_delivery_channels_status).
        ///
        /// <p>A list that contains the status of a specified delivery channel.</p>
        pub fn delivery_channels_status(
            mut self,
            input: crate::model::DeliveryChannelStatus,
        ) -> Self {
            let mut v = self.delivery_channels_status.unwrap_or_default();
            v.push(input);
            self.delivery_channels_status = Some(v);
            self
        }
        /// <p>A list that contains the status of a specified delivery channel.</p>
        pub fn set_delivery_channels_status(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeliveryChannelStatus>>,
        ) -> Self {
            self.delivery_channels_status = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeDeliveryChannelStatusOutput`](crate::output::DescribeDeliveryChannelStatusOutput)
        pub fn build(self) -> crate::output::DescribeDeliveryChannelStatusOutput {
            crate::output::DescribeDeliveryChannelStatusOutput {
                delivery_channels_status: self.delivery_channels_status,
            }
        }
    }
}
impl DescribeDeliveryChannelStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDeliveryChannelStatusOutput`](crate::output::DescribeDeliveryChannelStatusOutput)
    pub fn builder() -> crate::output::describe_delivery_channel_status_output::Builder {
        crate::output::describe_delivery_channel_status_output::Builder::default()
    }
}

/// <p>The output for the <code>DescribeDeliveryChannels</code> action.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDeliveryChannelsOutput {
    /// <p>A list that contains the descriptions of the specified delivery channel.</p>
    pub delivery_channels: std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
}
impl DescribeDeliveryChannelsOutput {
    /// <p>A list that contains the descriptions of the specified delivery channel.</p>
    pub fn delivery_channels(&self) -> std::option::Option<&[crate::model::DeliveryChannel]> {
        self.delivery_channels.as_deref()
    }
}
impl std::fmt::Debug for DescribeDeliveryChannelsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDeliveryChannelsOutput");
        formatter.field("delivery_channels", &self.delivery_channels);
        formatter.finish()
    }
}
/// See [`DescribeDeliveryChannelsOutput`](crate::output::DescribeDeliveryChannelsOutput)
pub mod describe_delivery_channels_output {
    /// A builder for [`DescribeDeliveryChannelsOutput`](crate::output::DescribeDeliveryChannelsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) delivery_channels:
            std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
    }
    impl Builder {
        /// Appends an item to `delivery_channels`.
        ///
        /// To override the contents of this collection use [`set_delivery_channels`](Self::set_delivery_channels).
        ///
        /// <p>A list that contains the descriptions of the specified delivery channel.</p>
        pub fn delivery_channels(mut self, input: crate::model::DeliveryChannel) -> Self {
            let mut v = self.delivery_channels.unwrap_or_default();
            v.push(input);
            self.delivery_channels = Some(v);
            self
        }
        /// <p>A list that contains the descriptions of the specified delivery channel.</p>
        pub fn set_delivery_channels(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
        ) -> Self {
            self.delivery_channels = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeDeliveryChannelsOutput`](crate::output::DescribeDeliveryChannelsOutput)
        pub fn build(self) -> crate::output::DescribeDeliveryChannelsOutput {
            crate::output::DescribeDeliveryChannelsOutput {
                delivery_channels: self.delivery_channels,
            }
        }
    }
}
impl DescribeDeliveryChannelsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDeliveryChannelsOutput`](crate::output::DescribeDeliveryChannelsOutput)
    pub fn builder() -> crate::output::describe_delivery_channels_output::Builder {
        crate::output::describe_delivery_channels_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConformancePackStatusOutput {
    /// <p>A list of <code>ConformancePackStatusDetail</code> objects.</p>
    pub conformance_pack_status_details:
        std::option::Option<std::vec::Vec<crate::model::ConformancePackStatusDetail>>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePackStatusOutput {
    /// <p>A list of <code>ConformancePackStatusDetail</code> objects.</p>
    pub fn conformance_pack_status_details(
        &self,
    ) -> std::option::Option<&[crate::model::ConformancePackStatusDetail]> {
        self.conformance_pack_status_details.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConformancePackStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConformancePackStatusOutput");
        formatter.field(
            "conformance_pack_status_details",
            &self.conformance_pack_status_details,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConformancePackStatusOutput`](crate::output::DescribeConformancePackStatusOutput)
pub mod describe_conformance_pack_status_output {
    /// A builder for [`DescribeConformancePackStatusOutput`](crate::output::DescribeConformancePackStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_status_details:
            std::option::Option<std::vec::Vec<crate::model::ConformancePackStatusDetail>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `conformance_pack_status_details`.
        ///
        /// To override the contents of this collection use [`set_conformance_pack_status_details`](Self::set_conformance_pack_status_details).
        ///
        /// <p>A list of <code>ConformancePackStatusDetail</code> objects.</p>
        pub fn conformance_pack_status_details(
            mut self,
            input: crate::model::ConformancePackStatusDetail,
        ) -> Self {
            let mut v = self.conformance_pack_status_details.unwrap_or_default();
            v.push(input);
            self.conformance_pack_status_details = Some(v);
            self
        }
        /// <p>A list of <code>ConformancePackStatusDetail</code> objects.</p>
        pub fn set_conformance_pack_status_details(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConformancePackStatusDetail>>,
        ) -> Self {
            self.conformance_pack_status_details = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConformancePackStatusOutput`](crate::output::DescribeConformancePackStatusOutput)
        pub fn build(self) -> crate::output::DescribeConformancePackStatusOutput {
            crate::output::DescribeConformancePackStatusOutput {
                conformance_pack_status_details: self.conformance_pack_status_details,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConformancePackStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConformancePackStatusOutput`](crate::output::DescribeConformancePackStatusOutput)
    pub fn builder() -> crate::output::describe_conformance_pack_status_output::Builder {
        crate::output::describe_conformance_pack_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConformancePacksOutput {
    /// <p>Returns a list of <code>ConformancePackDetail</code> objects.</p>
    pub conformance_pack_details:
        std::option::Option<std::vec::Vec<crate::model::ConformancePackDetail>>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePacksOutput {
    /// <p>Returns a list of <code>ConformancePackDetail</code> objects.</p>
    pub fn conformance_pack_details(
        &self,
    ) -> std::option::Option<&[crate::model::ConformancePackDetail]> {
        self.conformance_pack_details.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConformancePacksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConformancePacksOutput");
        formatter.field("conformance_pack_details", &self.conformance_pack_details);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConformancePacksOutput`](crate::output::DescribeConformancePacksOutput)
pub mod describe_conformance_packs_output {
    /// A builder for [`DescribeConformancePacksOutput`](crate::output::DescribeConformancePacksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_details:
            std::option::Option<std::vec::Vec<crate::model::ConformancePackDetail>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `conformance_pack_details`.
        ///
        /// To override the contents of this collection use [`set_conformance_pack_details`](Self::set_conformance_pack_details).
        ///
        /// <p>Returns a list of <code>ConformancePackDetail</code> objects.</p>
        pub fn conformance_pack_details(
            mut self,
            input: crate::model::ConformancePackDetail,
        ) -> Self {
            let mut v = self.conformance_pack_details.unwrap_or_default();
            v.push(input);
            self.conformance_pack_details = Some(v);
            self
        }
        /// <p>Returns a list of <code>ConformancePackDetail</code> objects.</p>
        pub fn set_conformance_pack_details(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConformancePackDetail>>,
        ) -> Self {
            self.conformance_pack_details = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConformancePacksOutput`](crate::output::DescribeConformancePacksOutput)
        pub fn build(self) -> crate::output::DescribeConformancePacksOutput {
            crate::output::DescribeConformancePacksOutput {
                conformance_pack_details: self.conformance_pack_details,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConformancePacksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConformancePacksOutput`](crate::output::DescribeConformancePacksOutput)
    pub fn builder() -> crate::output::describe_conformance_packs_output::Builder {
        crate::output::describe_conformance_packs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConformancePackComplianceOutput {
    /// <p>Name of the conformance pack.</p>
    pub conformance_pack_name: std::option::Option<std::string::String>,
    /// <p>Returns a list of <code>ConformancePackRuleCompliance</code> objects.</p>
    pub conformance_pack_rule_compliance_list:
        std::option::Option<std::vec::Vec<crate::model::ConformancePackRuleCompliance>>,
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePackComplianceOutput {
    /// <p>Name of the conformance pack.</p>
    pub fn conformance_pack_name(&self) -> std::option::Option<&str> {
        self.conformance_pack_name.as_deref()
    }
    /// <p>Returns a list of <code>ConformancePackRuleCompliance</code> objects.</p>
    pub fn conformance_pack_rule_compliance_list(
        &self,
    ) -> std::option::Option<&[crate::model::ConformancePackRuleCompliance]> {
        self.conformance_pack_rule_compliance_list.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConformancePackComplianceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConformancePackComplianceOutput");
        formatter.field("conformance_pack_name", &self.conformance_pack_name);
        formatter.field(
            "conformance_pack_rule_compliance_list",
            &self.conformance_pack_rule_compliance_list,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConformancePackComplianceOutput`](crate::output::DescribeConformancePackComplianceOutput)
pub mod describe_conformance_pack_compliance_output {
    /// A builder for [`DescribeConformancePackComplianceOutput`](crate::output::DescribeConformancePackComplianceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) conformance_pack_name: std::option::Option<std::string::String>,
        pub(crate) conformance_pack_rule_compliance_list:
            std::option::Option<std::vec::Vec<crate::model::ConformancePackRuleCompliance>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Name of the conformance pack.</p>
        pub fn conformance_pack_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.conformance_pack_name = Some(input.into());
            self
        }
        /// <p>Name of the conformance pack.</p>
        pub fn set_conformance_pack_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.conformance_pack_name = input;
            self
        }
        /// Appends an item to `conformance_pack_rule_compliance_list`.
        ///
        /// To override the contents of this collection use [`set_conformance_pack_rule_compliance_list`](Self::set_conformance_pack_rule_compliance_list).
        ///
        /// <p>Returns a list of <code>ConformancePackRuleCompliance</code> objects.</p>
        pub fn conformance_pack_rule_compliance_list(
            mut self,
            input: crate::model::ConformancePackRuleCompliance,
        ) -> Self {
            let mut v = self
                .conformance_pack_rule_compliance_list
                .unwrap_or_default();
            v.push(input);
            self.conformance_pack_rule_compliance_list = Some(v);
            self
        }
        /// <p>Returns a list of <code>ConformancePackRuleCompliance</code> objects.</p>
        pub fn set_conformance_pack_rule_compliance_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConformancePackRuleCompliance>>,
        ) -> Self {
            self.conformance_pack_rule_compliance_list = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned in a previous request that you use to request the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConformancePackComplianceOutput`](crate::output::DescribeConformancePackComplianceOutput)
        pub fn build(self) -> crate::output::DescribeConformancePackComplianceOutput {
            crate::output::DescribeConformancePackComplianceOutput {
                conformance_pack_name: self.conformance_pack_name,
                conformance_pack_rule_compliance_list: self.conformance_pack_rule_compliance_list,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConformancePackComplianceOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConformancePackComplianceOutput`](crate::output::DescribeConformancePackComplianceOutput)
    pub fn builder() -> crate::output::describe_conformance_pack_compliance_output::Builder {
        crate::output::describe_conformance_pack_compliance_output::Builder::default()
    }
}

/// <p>The output for the <code>DescribeConfigurationRecorderStatus</code> action, in JSON format.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigurationRecorderStatusOutput {
    /// <p>A list that contains status of the specified recorders.</p>
    pub configuration_recorders_status:
        std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorderStatus>>,
}
impl DescribeConfigurationRecorderStatusOutput {
    /// <p>A list that contains status of the specified recorders.</p>
    pub fn configuration_recorders_status(
        &self,
    ) -> std::option::Option<&[crate::model::ConfigurationRecorderStatus]> {
        self.configuration_recorders_status.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigurationRecorderStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigurationRecorderStatusOutput");
        formatter.field(
            "configuration_recorders_status",
            &self.configuration_recorders_status,
        );
        formatter.finish()
    }
}
/// See [`DescribeConfigurationRecorderStatusOutput`](crate::output::DescribeConfigurationRecorderStatusOutput)
pub mod describe_configuration_recorder_status_output {
    /// A builder for [`DescribeConfigurationRecorderStatusOutput`](crate::output::DescribeConfigurationRecorderStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_recorders_status:
            std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorderStatus>>,
    }
    impl Builder {
        /// Appends an item to `configuration_recorders_status`.
        ///
        /// To override the contents of this collection use [`set_configuration_recorders_status`](Self::set_configuration_recorders_status).
        ///
        /// <p>A list that contains status of the specified recorders.</p>
        pub fn configuration_recorders_status(
            mut self,
            input: crate::model::ConfigurationRecorderStatus,
        ) -> Self {
            let mut v = self.configuration_recorders_status.unwrap_or_default();
            v.push(input);
            self.configuration_recorders_status = Some(v);
            self
        }
        /// <p>A list that contains status of the specified recorders.</p>
        pub fn set_configuration_recorders_status(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorderStatus>>,
        ) -> Self {
            self.configuration_recorders_status = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigurationRecorderStatusOutput`](crate::output::DescribeConfigurationRecorderStatusOutput)
        pub fn build(self) -> crate::output::DescribeConfigurationRecorderStatusOutput {
            crate::output::DescribeConfigurationRecorderStatusOutput {
                configuration_recorders_status: self.configuration_recorders_status,
            }
        }
    }
}
impl DescribeConfigurationRecorderStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigurationRecorderStatusOutput`](crate::output::DescribeConfigurationRecorderStatusOutput)
    pub fn builder() -> crate::output::describe_configuration_recorder_status_output::Builder {
        crate::output::describe_configuration_recorder_status_output::Builder::default()
    }
}

/// <p>The output for the <code>DescribeConfigurationRecorders</code> action.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigurationRecordersOutput {
    /// <p>A list that contains the descriptions of the specified configuration recorders.</p>
    pub configuration_recorders:
        std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
}
impl DescribeConfigurationRecordersOutput {
    /// <p>A list that contains the descriptions of the specified configuration recorders.</p>
    pub fn configuration_recorders(
        &self,
    ) -> std::option::Option<&[crate::model::ConfigurationRecorder]> {
        self.configuration_recorders.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigurationRecordersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigurationRecordersOutput");
        formatter.field("configuration_recorders", &self.configuration_recorders);
        formatter.finish()
    }
}
/// See [`DescribeConfigurationRecordersOutput`](crate::output::DescribeConfigurationRecordersOutput)
pub mod describe_configuration_recorders_output {
    /// A builder for [`DescribeConfigurationRecordersOutput`](crate::output::DescribeConfigurationRecordersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_recorders:
            std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
    }
    impl Builder {
        /// Appends an item to `configuration_recorders`.
        ///
        /// To override the contents of this collection use [`set_configuration_recorders`](Self::set_configuration_recorders).
        ///
        /// <p>A list that contains the descriptions of the specified configuration recorders.</p>
        pub fn configuration_recorders(
            mut self,
            input: crate::model::ConfigurationRecorder,
        ) -> Self {
            let mut v = self.configuration_recorders.unwrap_or_default();
            v.push(input);
            self.configuration_recorders = Some(v);
            self
        }
        /// <p>A list that contains the descriptions of the specified configuration recorders.</p>
        pub fn set_configuration_recorders(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
        ) -> Self {
            self.configuration_recorders = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigurationRecordersOutput`](crate::output::DescribeConfigurationRecordersOutput)
        pub fn build(self) -> crate::output::DescribeConfigurationRecordersOutput {
            crate::output::DescribeConfigurationRecordersOutput {
                configuration_recorders: self.configuration_recorders,
            }
        }
    }
}
impl DescribeConfigurationRecordersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigurationRecordersOutput`](crate::output::DescribeConfigurationRecordersOutput)
    pub fn builder() -> crate::output::describe_configuration_recorders_output::Builder {
        crate::output::describe_configuration_recorders_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigurationAggregatorSourcesStatusOutput {
    /// <p>Returns an AggregatedSourceStatus object. </p>
    pub aggregated_source_status_list:
        std::option::Option<std::vec::Vec<crate::model::AggregatedSourceStatus>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigurationAggregatorSourcesStatusOutput {
    /// <p>Returns an AggregatedSourceStatus object. </p>
    pub fn aggregated_source_status_list(
        &self,
    ) -> std::option::Option<&[crate::model::AggregatedSourceStatus]> {
        self.aggregated_source_status_list.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigurationAggregatorSourcesStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigurationAggregatorSourcesStatusOutput");
        formatter.field(
            "aggregated_source_status_list",
            &self.aggregated_source_status_list,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConfigurationAggregatorSourcesStatusOutput`](crate::output::DescribeConfigurationAggregatorSourcesStatusOutput)
pub mod describe_configuration_aggregator_sources_status_output {
    /// A builder for [`DescribeConfigurationAggregatorSourcesStatusOutput`](crate::output::DescribeConfigurationAggregatorSourcesStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregated_source_status_list:
            std::option::Option<std::vec::Vec<crate::model::AggregatedSourceStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregated_source_status_list`.
        ///
        /// To override the contents of this collection use [`set_aggregated_source_status_list`](Self::set_aggregated_source_status_list).
        ///
        /// <p>Returns an AggregatedSourceStatus object. </p>
        pub fn aggregated_source_status_list(
            mut self,
            input: crate::model::AggregatedSourceStatus,
        ) -> Self {
            let mut v = self.aggregated_source_status_list.unwrap_or_default();
            v.push(input);
            self.aggregated_source_status_list = Some(v);
            self
        }
        /// <p>Returns an AggregatedSourceStatus object. </p>
        pub fn set_aggregated_source_status_list(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregatedSourceStatus>>,
        ) -> Self {
            self.aggregated_source_status_list = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigurationAggregatorSourcesStatusOutput`](crate::output::DescribeConfigurationAggregatorSourcesStatusOutput)
        pub fn build(self) -> crate::output::DescribeConfigurationAggregatorSourcesStatusOutput {
            crate::output::DescribeConfigurationAggregatorSourcesStatusOutput {
                aggregated_source_status_list: self.aggregated_source_status_list,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConfigurationAggregatorSourcesStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigurationAggregatorSourcesStatusOutput`](crate::output::DescribeConfigurationAggregatorSourcesStatusOutput)
    pub fn builder(
    ) -> crate::output::describe_configuration_aggregator_sources_status_output::Builder {
        crate::output::describe_configuration_aggregator_sources_status_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigurationAggregatorsOutput {
    /// <p>Returns a ConfigurationAggregators object.</p>
    pub configuration_aggregators:
        std::option::Option<std::vec::Vec<crate::model::ConfigurationAggregator>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigurationAggregatorsOutput {
    /// <p>Returns a ConfigurationAggregators object.</p>
    pub fn configuration_aggregators(
        &self,
    ) -> std::option::Option<&[crate::model::ConfigurationAggregator]> {
        self.configuration_aggregators.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigurationAggregatorsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigurationAggregatorsOutput");
        formatter.field("configuration_aggregators", &self.configuration_aggregators);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConfigurationAggregatorsOutput`](crate::output::DescribeConfigurationAggregatorsOutput)
pub mod describe_configuration_aggregators_output {
    /// A builder for [`DescribeConfigurationAggregatorsOutput`](crate::output::DescribeConfigurationAggregatorsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_aggregators:
            std::option::Option<std::vec::Vec<crate::model::ConfigurationAggregator>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `configuration_aggregators`.
        ///
        /// To override the contents of this collection use [`set_configuration_aggregators`](Self::set_configuration_aggregators).
        ///
        /// <p>Returns a ConfigurationAggregators object.</p>
        pub fn configuration_aggregators(
            mut self,
            input: crate::model::ConfigurationAggregator,
        ) -> Self {
            let mut v = self.configuration_aggregators.unwrap_or_default();
            v.push(input);
            self.configuration_aggregators = Some(v);
            self
        }
        /// <p>Returns a ConfigurationAggregators object.</p>
        pub fn set_configuration_aggregators(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigurationAggregator>>,
        ) -> Self {
            self.configuration_aggregators = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigurationAggregatorsOutput`](crate::output::DescribeConfigurationAggregatorsOutput)
        pub fn build(self) -> crate::output::DescribeConfigurationAggregatorsOutput {
            crate::output::DescribeConfigurationAggregatorsOutput {
                configuration_aggregators: self.configuration_aggregators,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConfigurationAggregatorsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigurationAggregatorsOutput`](crate::output::DescribeConfigurationAggregatorsOutput)
    pub fn builder() -> crate::output::describe_configuration_aggregators_output::Builder {
        crate::output::describe_configuration_aggregators_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigRulesOutput {
    /// <p>The details about your Config rules.</p>
    pub config_rules: std::option::Option<std::vec::Vec<crate::model::ConfigRule>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigRulesOutput {
    /// <p>The details about your Config rules.</p>
    pub fn config_rules(&self) -> std::option::Option<&[crate::model::ConfigRule]> {
        self.config_rules.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigRulesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigRulesOutput");
        formatter.field("config_rules", &self.config_rules);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConfigRulesOutput`](crate::output::DescribeConfigRulesOutput)
pub mod describe_config_rules_output {
    /// A builder for [`DescribeConfigRulesOutput`](crate::output::DescribeConfigRulesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) config_rules: std::option::Option<std::vec::Vec<crate::model::ConfigRule>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `config_rules`.
        ///
        /// To override the contents of this collection use [`set_config_rules`](Self::set_config_rules).
        ///
        /// <p>The details about your Config rules.</p>
        pub fn config_rules(mut self, input: crate::model::ConfigRule) -> Self {
            let mut v = self.config_rules.unwrap_or_default();
            v.push(input);
            self.config_rules = Some(v);
            self
        }
        /// <p>The details about your Config rules.</p>
        pub fn set_config_rules(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigRule>>,
        ) -> Self {
            self.config_rules = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigRulesOutput`](crate::output::DescribeConfigRulesOutput)
        pub fn build(self) -> crate::output::DescribeConfigRulesOutput {
            crate::output::DescribeConfigRulesOutput {
                config_rules: self.config_rules,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConfigRulesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigRulesOutput`](crate::output::DescribeConfigRulesOutput)
    pub fn builder() -> crate::output::describe_config_rules_output::Builder {
        crate::output::describe_config_rules_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeConfigRuleEvaluationStatusOutput {
    /// <p>Status information about your Config managed rules.</p>
    pub config_rules_evaluation_status:
        std::option::Option<std::vec::Vec<crate::model::ConfigRuleEvaluationStatus>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigRuleEvaluationStatusOutput {
    /// <p>Status information about your Config managed rules.</p>
    pub fn config_rules_evaluation_status(
        &self,
    ) -> std::option::Option<&[crate::model::ConfigRuleEvaluationStatus]> {
        self.config_rules_evaluation_status.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeConfigRuleEvaluationStatusOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeConfigRuleEvaluationStatusOutput");
        formatter.field(
            "config_rules_evaluation_status",
            &self.config_rules_evaluation_status,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeConfigRuleEvaluationStatusOutput`](crate::output::DescribeConfigRuleEvaluationStatusOutput)
pub mod describe_config_rule_evaluation_status_output {
    /// A builder for [`DescribeConfigRuleEvaluationStatusOutput`](crate::output::DescribeConfigRuleEvaluationStatusOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) config_rules_evaluation_status:
            std::option::Option<std::vec::Vec<crate::model::ConfigRuleEvaluationStatus>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `config_rules_evaluation_status`.
        ///
        /// To override the contents of this collection use [`set_config_rules_evaluation_status`](Self::set_config_rules_evaluation_status).
        ///
        /// <p>Status information about your Config managed rules.</p>
        pub fn config_rules_evaluation_status(
            mut self,
            input: crate::model::ConfigRuleEvaluationStatus,
        ) -> Self {
            let mut v = self.config_rules_evaluation_status.unwrap_or_default();
            v.push(input);
            self.config_rules_evaluation_status = Some(v);
            self
        }
        /// <p>Status information about your Config managed rules.</p>
        pub fn set_config_rules_evaluation_status(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ConfigRuleEvaluationStatus>>,
        ) -> Self {
            self.config_rules_evaluation_status = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeConfigRuleEvaluationStatusOutput`](crate::output::DescribeConfigRuleEvaluationStatusOutput)
        pub fn build(self) -> crate::output::DescribeConfigRuleEvaluationStatusOutput {
            crate::output::DescribeConfigRuleEvaluationStatusOutput {
                config_rules_evaluation_status: self.config_rules_evaluation_status,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeConfigRuleEvaluationStatusOutput {
    /// Creates a new builder-style object to manufacture [`DescribeConfigRuleEvaluationStatusOutput`](crate::output::DescribeConfigRuleEvaluationStatusOutput)
    pub fn builder() -> crate::output::describe_config_rule_evaluation_status_output::Builder {
        crate::output::describe_config_rule_evaluation_status_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeComplianceByResourceOutput {
    /// <p>Indicates whether the specified Amazon Web Services resource complies with all of the Config rules that evaluate it.</p>
    pub compliance_by_resources:
        std::option::Option<std::vec::Vec<crate::model::ComplianceByResource>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeComplianceByResourceOutput {
    /// <p>Indicates whether the specified Amazon Web Services resource complies with all of the Config rules that evaluate it.</p>
    pub fn compliance_by_resources(
        &self,
    ) -> std::option::Option<&[crate::model::ComplianceByResource]> {
        self.compliance_by_resources.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeComplianceByResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeComplianceByResourceOutput");
        formatter.field("compliance_by_resources", &self.compliance_by_resources);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeComplianceByResourceOutput`](crate::output::DescribeComplianceByResourceOutput)
pub mod describe_compliance_by_resource_output {
    /// A builder for [`DescribeComplianceByResourceOutput`](crate::output::DescribeComplianceByResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) compliance_by_resources:
            std::option::Option<std::vec::Vec<crate::model::ComplianceByResource>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `compliance_by_resources`.
        ///
        /// To override the contents of this collection use [`set_compliance_by_resources`](Self::set_compliance_by_resources).
        ///
        /// <p>Indicates whether the specified Amazon Web Services resource complies with all of the Config rules that evaluate it.</p>
        pub fn compliance_by_resources(
            mut self,
            input: crate::model::ComplianceByResource,
        ) -> Self {
            let mut v = self.compliance_by_resources.unwrap_or_default();
            v.push(input);
            self.compliance_by_resources = Some(v);
            self
        }
        /// <p>Indicates whether the specified Amazon Web Services resource complies with all of the Config rules that evaluate it.</p>
        pub fn set_compliance_by_resources(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ComplianceByResource>>,
        ) -> Self {
            self.compliance_by_resources = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeComplianceByResourceOutput`](crate::output::DescribeComplianceByResourceOutput)
        pub fn build(self) -> crate::output::DescribeComplianceByResourceOutput {
            crate::output::DescribeComplianceByResourceOutput {
                compliance_by_resources: self.compliance_by_resources,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeComplianceByResourceOutput {
    /// Creates a new builder-style object to manufacture [`DescribeComplianceByResourceOutput`](crate::output::DescribeComplianceByResourceOutput)
    pub fn builder() -> crate::output::describe_compliance_by_resource_output::Builder {
        crate::output::describe_compliance_by_resource_output::Builder::default()
    }
}

/// <p></p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeComplianceByConfigRuleOutput {
    /// <p>Indicates whether each of the specified Config rules is compliant.</p>
    pub compliance_by_config_rules:
        std::option::Option<std::vec::Vec<crate::model::ComplianceByConfigRule>>,
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeComplianceByConfigRuleOutput {
    /// <p>Indicates whether each of the specified Config rules is compliant.</p>
    pub fn compliance_by_config_rules(
        &self,
    ) -> std::option::Option<&[crate::model::ComplianceByConfigRule]> {
        self.compliance_by_config_rules.as_deref()
    }
    /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeComplianceByConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeComplianceByConfigRuleOutput");
        formatter.field(
            "compliance_by_config_rules",
            &self.compliance_by_config_rules,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeComplianceByConfigRuleOutput`](crate::output::DescribeComplianceByConfigRuleOutput)
pub mod describe_compliance_by_config_rule_output {
    /// A builder for [`DescribeComplianceByConfigRuleOutput`](crate::output::DescribeComplianceByConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) compliance_by_config_rules:
            std::option::Option<std::vec::Vec<crate::model::ComplianceByConfigRule>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `compliance_by_config_rules`.
        ///
        /// To override the contents of this collection use [`set_compliance_by_config_rules`](Self::set_compliance_by_config_rules).
        ///
        /// <p>Indicates whether each of the specified Config rules is compliant.</p>
        pub fn compliance_by_config_rules(
            mut self,
            input: crate::model::ComplianceByConfigRule,
        ) -> Self {
            let mut v = self.compliance_by_config_rules.unwrap_or_default();
            v.push(input);
            self.compliance_by_config_rules = Some(v);
            self
        }
        /// <p>Indicates whether each of the specified Config rules is compliant.</p>
        pub fn set_compliance_by_config_rules(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ComplianceByConfigRule>>,
        ) -> Self {
            self.compliance_by_config_rules = input;
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The string that you use in a subsequent request to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeComplianceByConfigRuleOutput`](crate::output::DescribeComplianceByConfigRuleOutput)
        pub fn build(self) -> crate::output::DescribeComplianceByConfigRuleOutput {
            crate::output::DescribeComplianceByConfigRuleOutput {
                compliance_by_config_rules: self.compliance_by_config_rules,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeComplianceByConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`DescribeComplianceByConfigRuleOutput`](crate::output::DescribeComplianceByConfigRuleOutput)
    pub fn builder() -> crate::output::describe_compliance_by_config_rule_output::Builder {
        crate::output::describe_compliance_by_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAggregationAuthorizationsOutput {
    /// <p>Returns a list of authorizations granted to various aggregator accounts and regions.</p>
    pub aggregation_authorizations:
        std::option::Option<std::vec::Vec<crate::model::AggregationAuthorization>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregationAuthorizationsOutput {
    /// <p>Returns a list of authorizations granted to various aggregator accounts and regions.</p>
    pub fn aggregation_authorizations(
        &self,
    ) -> std::option::Option<&[crate::model::AggregationAuthorization]> {
        self.aggregation_authorizations.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeAggregationAuthorizationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAggregationAuthorizationsOutput");
        formatter.field(
            "aggregation_authorizations",
            &self.aggregation_authorizations,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAggregationAuthorizationsOutput`](crate::output::DescribeAggregationAuthorizationsOutput)
pub mod describe_aggregation_authorizations_output {
    /// A builder for [`DescribeAggregationAuthorizationsOutput`](crate::output::DescribeAggregationAuthorizationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregation_authorizations:
            std::option::Option<std::vec::Vec<crate::model::AggregationAuthorization>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregation_authorizations`.
        ///
        /// To override the contents of this collection use [`set_aggregation_authorizations`](Self::set_aggregation_authorizations).
        ///
        /// <p>Returns a list of authorizations granted to various aggregator accounts and regions.</p>
        pub fn aggregation_authorizations(
            mut self,
            input: crate::model::AggregationAuthorization,
        ) -> Self {
            let mut v = self.aggregation_authorizations.unwrap_or_default();
            v.push(input);
            self.aggregation_authorizations = Some(v);
            self
        }
        /// <p>Returns a list of authorizations granted to various aggregator accounts and regions.</p>
        pub fn set_aggregation_authorizations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregationAuthorization>>,
        ) -> Self {
            self.aggregation_authorizations = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAggregationAuthorizationsOutput`](crate::output::DescribeAggregationAuthorizationsOutput)
        pub fn build(self) -> crate::output::DescribeAggregationAuthorizationsOutput {
            crate::output::DescribeAggregationAuthorizationsOutput {
                aggregation_authorizations: self.aggregation_authorizations,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAggregationAuthorizationsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAggregationAuthorizationsOutput`](crate::output::DescribeAggregationAuthorizationsOutput)
    pub fn builder() -> crate::output::describe_aggregation_authorizations_output::Builder {
        crate::output::describe_aggregation_authorizations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAggregateComplianceByConformancePacksOutput {
    /// <p>Returns the <code>AggregateComplianceByConformancePack</code> object.</p>
    pub aggregate_compliance_by_conformance_packs:
        std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConformancePack>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregateComplianceByConformancePacksOutput {
    /// <p>Returns the <code>AggregateComplianceByConformancePack</code> object.</p>
    pub fn aggregate_compliance_by_conformance_packs(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateComplianceByConformancePack]> {
        self.aggregate_compliance_by_conformance_packs.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeAggregateComplianceByConformancePacksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAggregateComplianceByConformancePacksOutput");
        formatter.field(
            "aggregate_compliance_by_conformance_packs",
            &self.aggregate_compliance_by_conformance_packs,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAggregateComplianceByConformancePacksOutput`](crate::output::DescribeAggregateComplianceByConformancePacksOutput)
pub mod describe_aggregate_compliance_by_conformance_packs_output {
    /// A builder for [`DescribeAggregateComplianceByConformancePacksOutput`](crate::output::DescribeAggregateComplianceByConformancePacksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregate_compliance_by_conformance_packs:
            std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConformancePack>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregate_compliance_by_conformance_packs`.
        ///
        /// To override the contents of this collection use [`set_aggregate_compliance_by_conformance_packs`](Self::set_aggregate_compliance_by_conformance_packs).
        ///
        /// <p>Returns the <code>AggregateComplianceByConformancePack</code> object.</p>
        pub fn aggregate_compliance_by_conformance_packs(
            mut self,
            input: crate::model::AggregateComplianceByConformancePack,
        ) -> Self {
            let mut v = self
                .aggregate_compliance_by_conformance_packs
                .unwrap_or_default();
            v.push(input);
            self.aggregate_compliance_by_conformance_packs = Some(v);
            self
        }
        /// <p>Returns the <code>AggregateComplianceByConformancePack</code> object.</p>
        pub fn set_aggregate_compliance_by_conformance_packs(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::AggregateComplianceByConformancePack>,
            >,
        ) -> Self {
            self.aggregate_compliance_by_conformance_packs = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAggregateComplianceByConformancePacksOutput`](crate::output::DescribeAggregateComplianceByConformancePacksOutput)
        pub fn build(self) -> crate::output::DescribeAggregateComplianceByConformancePacksOutput {
            crate::output::DescribeAggregateComplianceByConformancePacksOutput {
                aggregate_compliance_by_conformance_packs: self
                    .aggregate_compliance_by_conformance_packs,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAggregateComplianceByConformancePacksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAggregateComplianceByConformancePacksOutput`](crate::output::DescribeAggregateComplianceByConformancePacksOutput)
    pub fn builder(
    ) -> crate::output::describe_aggregate_compliance_by_conformance_packs_output::Builder {
        crate::output::describe_aggregate_compliance_by_conformance_packs_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAggregateComplianceByConfigRulesOutput {
    /// <p>Returns a list of AggregateComplianceByConfigRule object.</p>
    pub aggregate_compliance_by_config_rules:
        std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConfigRule>>,
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregateComplianceByConfigRulesOutput {
    /// <p>Returns a list of AggregateComplianceByConfigRule object.</p>
    pub fn aggregate_compliance_by_config_rules(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateComplianceByConfigRule]> {
        self.aggregate_compliance_by_config_rules.as_deref()
    }
    /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for DescribeAggregateComplianceByConfigRulesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAggregateComplianceByConfigRulesOutput");
        formatter.field(
            "aggregate_compliance_by_config_rules",
            &self.aggregate_compliance_by_config_rules,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAggregateComplianceByConfigRulesOutput`](crate::output::DescribeAggregateComplianceByConfigRulesOutput)
pub mod describe_aggregate_compliance_by_config_rules_output {
    /// A builder for [`DescribeAggregateComplianceByConfigRulesOutput`](crate::output::DescribeAggregateComplianceByConfigRulesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) aggregate_compliance_by_config_rules:
            std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConfigRule>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `aggregate_compliance_by_config_rules`.
        ///
        /// To override the contents of this collection use [`set_aggregate_compliance_by_config_rules`](Self::set_aggregate_compliance_by_config_rules).
        ///
        /// <p>Returns a list of AggregateComplianceByConfigRule object.</p>
        pub fn aggregate_compliance_by_config_rules(
            mut self,
            input: crate::model::AggregateComplianceByConfigRule,
        ) -> Self {
            let mut v = self
                .aggregate_compliance_by_config_rules
                .unwrap_or_default();
            v.push(input);
            self.aggregate_compliance_by_config_rules = Some(v);
            self
        }
        /// <p>Returns a list of AggregateComplianceByConfigRule object.</p>
        pub fn set_aggregate_compliance_by_config_rules(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::AggregateComplianceByConfigRule>,
            >,
        ) -> Self {
            self.aggregate_compliance_by_config_rules = input;
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The <code>nextToken</code> string returned on a previous page that you use to get the next page of results in a paginated response.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAggregateComplianceByConfigRulesOutput`](crate::output::DescribeAggregateComplianceByConfigRulesOutput)
        pub fn build(self) -> crate::output::DescribeAggregateComplianceByConfigRulesOutput {
            crate::output::DescribeAggregateComplianceByConfigRulesOutput {
                aggregate_compliance_by_config_rules: self.aggregate_compliance_by_config_rules,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAggregateComplianceByConfigRulesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAggregateComplianceByConfigRulesOutput`](crate::output::DescribeAggregateComplianceByConfigRulesOutput)
    pub fn builder() -> crate::output::describe_aggregate_compliance_by_config_rules_output::Builder
    {
        crate::output::describe_aggregate_compliance_by_config_rules_output::Builder::default()
    }
}

/// <p>The output for the <code>DeliverConfigSnapshot</code> action, in JSON format.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeliverConfigSnapshotOutput {
    /// <p>The ID of the snapshot that is being created.</p>
    pub config_snapshot_id: std::option::Option<std::string::String>,
}
impl DeliverConfigSnapshotOutput {
    /// <p>The ID of the snapshot that is being created.</p>
    pub fn config_snapshot_id(&self) -> std::option::Option<&str> {
        self.config_snapshot_id.as_deref()
    }
}
impl std::fmt::Debug for DeliverConfigSnapshotOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeliverConfigSnapshotOutput");
        formatter.field("config_snapshot_id", &self.config_snapshot_id);
        formatter.finish()
    }
}
/// See [`DeliverConfigSnapshotOutput`](crate::output::DeliverConfigSnapshotOutput)
pub mod deliver_config_snapshot_output {
    /// A builder for [`DeliverConfigSnapshotOutput`](crate::output::DeliverConfigSnapshotOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) config_snapshot_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ID of the snapshot that is being created.</p>
        pub fn config_snapshot_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.config_snapshot_id = Some(input.into());
            self
        }
        /// <p>The ID of the snapshot that is being created.</p>
        pub fn set_config_snapshot_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.config_snapshot_id = input;
            self
        }
        /// Consumes the builder and constructs a [`DeliverConfigSnapshotOutput`](crate::output::DeliverConfigSnapshotOutput)
        pub fn build(self) -> crate::output::DeliverConfigSnapshotOutput {
            crate::output::DeliverConfigSnapshotOutput {
                config_snapshot_id: self.config_snapshot_id,
            }
        }
    }
}
impl DeliverConfigSnapshotOutput {
    /// Creates a new builder-style object to manufacture [`DeliverConfigSnapshotOutput`](crate::output::DeliverConfigSnapshotOutput)
    pub fn builder() -> crate::output::deliver_config_snapshot_output::Builder {
        crate::output::deliver_config_snapshot_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteStoredQueryOutput {}
impl std::fmt::Debug for DeleteStoredQueryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteStoredQueryOutput");
        formatter.finish()
    }
}
/// See [`DeleteStoredQueryOutput`](crate::output::DeleteStoredQueryOutput)
pub mod delete_stored_query_output {
    /// A builder for [`DeleteStoredQueryOutput`](crate::output::DeleteStoredQueryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteStoredQueryOutput`](crate::output::DeleteStoredQueryOutput)
        pub fn build(self) -> crate::output::DeleteStoredQueryOutput {
            crate::output::DeleteStoredQueryOutput {}
        }
    }
}
impl DeleteStoredQueryOutput {
    /// Creates a new builder-style object to manufacture [`DeleteStoredQueryOutput`](crate::output::DeleteStoredQueryOutput)
    pub fn builder() -> crate::output::delete_stored_query_output::Builder {
        crate::output::delete_stored_query_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteRetentionConfigurationOutput {}
impl std::fmt::Debug for DeleteRetentionConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteRetentionConfigurationOutput");
        formatter.finish()
    }
}
/// See [`DeleteRetentionConfigurationOutput`](crate::output::DeleteRetentionConfigurationOutput)
pub mod delete_retention_configuration_output {
    /// A builder for [`DeleteRetentionConfigurationOutput`](crate::output::DeleteRetentionConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteRetentionConfigurationOutput`](crate::output::DeleteRetentionConfigurationOutput)
        pub fn build(self) -> crate::output::DeleteRetentionConfigurationOutput {
            crate::output::DeleteRetentionConfigurationOutput {}
        }
    }
}
impl DeleteRetentionConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`DeleteRetentionConfigurationOutput`](crate::output::DeleteRetentionConfigurationOutput)
    pub fn builder() -> crate::output::delete_retention_configuration_output::Builder {
        crate::output::delete_retention_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteResourceConfigOutput {}
impl std::fmt::Debug for DeleteResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteResourceConfigOutput");
        formatter.finish()
    }
}
/// See [`DeleteResourceConfigOutput`](crate::output::DeleteResourceConfigOutput)
pub mod delete_resource_config_output {
    /// A builder for [`DeleteResourceConfigOutput`](crate::output::DeleteResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteResourceConfigOutput`](crate::output::DeleteResourceConfigOutput)
        pub fn build(self) -> crate::output::DeleteResourceConfigOutput {
            crate::output::DeleteResourceConfigOutput {}
        }
    }
}
impl DeleteResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`DeleteResourceConfigOutput`](crate::output::DeleteResourceConfigOutput)
    pub fn builder() -> crate::output::delete_resource_config_output::Builder {
        crate::output::delete_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteRemediationExceptionsOutput {
    /// <p>Returns a list of failed delete remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
    pub failed_batches:
        std::option::Option<std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>>,
}
impl DeleteRemediationExceptionsOutput {
    /// <p>Returns a list of failed delete remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
    pub fn failed_batches(
        &self,
    ) -> std::option::Option<&[crate::model::FailedDeleteRemediationExceptionsBatch]> {
        self.failed_batches.as_deref()
    }
}
impl std::fmt::Debug for DeleteRemediationExceptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteRemediationExceptionsOutput");
        formatter.field("failed_batches", &self.failed_batches);
        formatter.finish()
    }
}
/// See [`DeleteRemediationExceptionsOutput`](crate::output::DeleteRemediationExceptionsOutput)
pub mod delete_remediation_exceptions_output {
    /// A builder for [`DeleteRemediationExceptionsOutput`](crate::output::DeleteRemediationExceptionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failed_batches: std::option::Option<
            std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>,
        >,
    }
    impl Builder {
        /// Appends an item to `failed_batches`.
        ///
        /// To override the contents of this collection use [`set_failed_batches`](Self::set_failed_batches).
        ///
        /// <p>Returns a list of failed delete remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
        pub fn failed_batches(
            mut self,
            input: crate::model::FailedDeleteRemediationExceptionsBatch,
        ) -> Self {
            let mut v = self.failed_batches.unwrap_or_default();
            v.push(input);
            self.failed_batches = Some(v);
            self
        }
        /// <p>Returns a list of failed delete remediation exceptions batch objects. Each object in the batch consists of a list of failed items and failure messages.</p>
        pub fn set_failed_batches(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>,
            >,
        ) -> Self {
            self.failed_batches = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteRemediationExceptionsOutput`](crate::output::DeleteRemediationExceptionsOutput)
        pub fn build(self) -> crate::output::DeleteRemediationExceptionsOutput {
            crate::output::DeleteRemediationExceptionsOutput {
                failed_batches: self.failed_batches,
            }
        }
    }
}
impl DeleteRemediationExceptionsOutput {
    /// Creates a new builder-style object to manufacture [`DeleteRemediationExceptionsOutput`](crate::output::DeleteRemediationExceptionsOutput)
    pub fn builder() -> crate::output::delete_remediation_exceptions_output::Builder {
        crate::output::delete_remediation_exceptions_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteRemediationConfigurationOutput {}
impl std::fmt::Debug for DeleteRemediationConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteRemediationConfigurationOutput");
        formatter.finish()
    }
}
/// See [`DeleteRemediationConfigurationOutput`](crate::output::DeleteRemediationConfigurationOutput)
pub mod delete_remediation_configuration_output {
    /// A builder for [`DeleteRemediationConfigurationOutput`](crate::output::DeleteRemediationConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteRemediationConfigurationOutput`](crate::output::DeleteRemediationConfigurationOutput)
        pub fn build(self) -> crate::output::DeleteRemediationConfigurationOutput {
            crate::output::DeleteRemediationConfigurationOutput {}
        }
    }
}
impl DeleteRemediationConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`DeleteRemediationConfigurationOutput`](crate::output::DeleteRemediationConfigurationOutput)
    pub fn builder() -> crate::output::delete_remediation_configuration_output::Builder {
        crate::output::delete_remediation_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeletePendingAggregationRequestOutput {}
impl std::fmt::Debug for DeletePendingAggregationRequestOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeletePendingAggregationRequestOutput");
        formatter.finish()
    }
}
/// See [`DeletePendingAggregationRequestOutput`](crate::output::DeletePendingAggregationRequestOutput)
pub mod delete_pending_aggregation_request_output {
    /// A builder for [`DeletePendingAggregationRequestOutput`](crate::output::DeletePendingAggregationRequestOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeletePendingAggregationRequestOutput`](crate::output::DeletePendingAggregationRequestOutput)
        pub fn build(self) -> crate::output::DeletePendingAggregationRequestOutput {
            crate::output::DeletePendingAggregationRequestOutput {}
        }
    }
}
impl DeletePendingAggregationRequestOutput {
    /// Creates a new builder-style object to manufacture [`DeletePendingAggregationRequestOutput`](crate::output::DeletePendingAggregationRequestOutput)
    pub fn builder() -> crate::output::delete_pending_aggregation_request_output::Builder {
        crate::output::delete_pending_aggregation_request_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteOrganizationConformancePackOutput {}
impl std::fmt::Debug for DeleteOrganizationConformancePackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteOrganizationConformancePackOutput");
        formatter.finish()
    }
}
/// See [`DeleteOrganizationConformancePackOutput`](crate::output::DeleteOrganizationConformancePackOutput)
pub mod delete_organization_conformance_pack_output {
    /// A builder for [`DeleteOrganizationConformancePackOutput`](crate::output::DeleteOrganizationConformancePackOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteOrganizationConformancePackOutput`](crate::output::DeleteOrganizationConformancePackOutput)
        pub fn build(self) -> crate::output::DeleteOrganizationConformancePackOutput {
            crate::output::DeleteOrganizationConformancePackOutput {}
        }
    }
}
impl DeleteOrganizationConformancePackOutput {
    /// Creates a new builder-style object to manufacture [`DeleteOrganizationConformancePackOutput`](crate::output::DeleteOrganizationConformancePackOutput)
    pub fn builder() -> crate::output::delete_organization_conformance_pack_output::Builder {
        crate::output::delete_organization_conformance_pack_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteOrganizationConfigRuleOutput {}
impl std::fmt::Debug for DeleteOrganizationConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteOrganizationConfigRuleOutput");
        formatter.finish()
    }
}
/// See [`DeleteOrganizationConfigRuleOutput`](crate::output::DeleteOrganizationConfigRuleOutput)
pub mod delete_organization_config_rule_output {
    /// A builder for [`DeleteOrganizationConfigRuleOutput`](crate::output::DeleteOrganizationConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteOrganizationConfigRuleOutput`](crate::output::DeleteOrganizationConfigRuleOutput)
        pub fn build(self) -> crate::output::DeleteOrganizationConfigRuleOutput {
            crate::output::DeleteOrganizationConfigRuleOutput {}
        }
    }
}
impl DeleteOrganizationConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`DeleteOrganizationConfigRuleOutput`](crate::output::DeleteOrganizationConfigRuleOutput)
    pub fn builder() -> crate::output::delete_organization_config_rule_output::Builder {
        crate::output::delete_organization_config_rule_output::Builder::default()
    }
}

/// <p>The output when you delete the evaluation results for the specified Config rule.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteEvaluationResultsOutput {}
impl std::fmt::Debug for DeleteEvaluationResultsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteEvaluationResultsOutput");
        formatter.finish()
    }
}
/// See [`DeleteEvaluationResultsOutput`](crate::output::DeleteEvaluationResultsOutput)
pub mod delete_evaluation_results_output {
    /// A builder for [`DeleteEvaluationResultsOutput`](crate::output::DeleteEvaluationResultsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteEvaluationResultsOutput`](crate::output::DeleteEvaluationResultsOutput)
        pub fn build(self) -> crate::output::DeleteEvaluationResultsOutput {
            crate::output::DeleteEvaluationResultsOutput {}
        }
    }
}
impl DeleteEvaluationResultsOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEvaluationResultsOutput`](crate::output::DeleteEvaluationResultsOutput)
    pub fn builder() -> crate::output::delete_evaluation_results_output::Builder {
        crate::output::delete_evaluation_results_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteDeliveryChannelOutput {}
impl std::fmt::Debug for DeleteDeliveryChannelOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteDeliveryChannelOutput");
        formatter.finish()
    }
}
/// See [`DeleteDeliveryChannelOutput`](crate::output::DeleteDeliveryChannelOutput)
pub mod delete_delivery_channel_output {
    /// A builder for [`DeleteDeliveryChannelOutput`](crate::output::DeleteDeliveryChannelOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteDeliveryChannelOutput`](crate::output::DeleteDeliveryChannelOutput)
        pub fn build(self) -> crate::output::DeleteDeliveryChannelOutput {
            crate::output::DeleteDeliveryChannelOutput {}
        }
    }
}
impl DeleteDeliveryChannelOutput {
    /// Creates a new builder-style object to manufacture [`DeleteDeliveryChannelOutput`](crate::output::DeleteDeliveryChannelOutput)
    pub fn builder() -> crate::output::delete_delivery_channel_output::Builder {
        crate::output::delete_delivery_channel_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConformancePackOutput {}
impl std::fmt::Debug for DeleteConformancePackOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConformancePackOutput");
        formatter.finish()
    }
}
/// See [`DeleteConformancePackOutput`](crate::output::DeleteConformancePackOutput)
pub mod delete_conformance_pack_output {
    /// A builder for [`DeleteConformancePackOutput`](crate::output::DeleteConformancePackOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteConformancePackOutput`](crate::output::DeleteConformancePackOutput)
        pub fn build(self) -> crate::output::DeleteConformancePackOutput {
            crate::output::DeleteConformancePackOutput {}
        }
    }
}
impl DeleteConformancePackOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConformancePackOutput`](crate::output::DeleteConformancePackOutput)
    pub fn builder() -> crate::output::delete_conformance_pack_output::Builder {
        crate::output::delete_conformance_pack_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConfigurationRecorderOutput {}
impl std::fmt::Debug for DeleteConfigurationRecorderOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConfigurationRecorderOutput");
        formatter.finish()
    }
}
/// See [`DeleteConfigurationRecorderOutput`](crate::output::DeleteConfigurationRecorderOutput)
pub mod delete_configuration_recorder_output {
    /// A builder for [`DeleteConfigurationRecorderOutput`](crate::output::DeleteConfigurationRecorderOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteConfigurationRecorderOutput`](crate::output::DeleteConfigurationRecorderOutput)
        pub fn build(self) -> crate::output::DeleteConfigurationRecorderOutput {
            crate::output::DeleteConfigurationRecorderOutput {}
        }
    }
}
impl DeleteConfigurationRecorderOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConfigurationRecorderOutput`](crate::output::DeleteConfigurationRecorderOutput)
    pub fn builder() -> crate::output::delete_configuration_recorder_output::Builder {
        crate::output::delete_configuration_recorder_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConfigurationAggregatorOutput {}
impl std::fmt::Debug for DeleteConfigurationAggregatorOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConfigurationAggregatorOutput");
        formatter.finish()
    }
}
/// See [`DeleteConfigurationAggregatorOutput`](crate::output::DeleteConfigurationAggregatorOutput)
pub mod delete_configuration_aggregator_output {
    /// A builder for [`DeleteConfigurationAggregatorOutput`](crate::output::DeleteConfigurationAggregatorOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteConfigurationAggregatorOutput`](crate::output::DeleteConfigurationAggregatorOutput)
        pub fn build(self) -> crate::output::DeleteConfigurationAggregatorOutput {
            crate::output::DeleteConfigurationAggregatorOutput {}
        }
    }
}
impl DeleteConfigurationAggregatorOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConfigurationAggregatorOutput`](crate::output::DeleteConfigurationAggregatorOutput)
    pub fn builder() -> crate::output::delete_configuration_aggregator_output::Builder {
        crate::output::delete_configuration_aggregator_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConfigRuleOutput {}
impl std::fmt::Debug for DeleteConfigRuleOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConfigRuleOutput");
        formatter.finish()
    }
}
/// See [`DeleteConfigRuleOutput`](crate::output::DeleteConfigRuleOutput)
pub mod delete_config_rule_output {
    /// A builder for [`DeleteConfigRuleOutput`](crate::output::DeleteConfigRuleOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteConfigRuleOutput`](crate::output::DeleteConfigRuleOutput)
        pub fn build(self) -> crate::output::DeleteConfigRuleOutput {
            crate::output::DeleteConfigRuleOutput {}
        }
    }
}
impl DeleteConfigRuleOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConfigRuleOutput`](crate::output::DeleteConfigRuleOutput)
    pub fn builder() -> crate::output::delete_config_rule_output::Builder {
        crate::output::delete_config_rule_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteAggregationAuthorizationOutput {}
impl std::fmt::Debug for DeleteAggregationAuthorizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteAggregationAuthorizationOutput");
        formatter.finish()
    }
}
/// See [`DeleteAggregationAuthorizationOutput`](crate::output::DeleteAggregationAuthorizationOutput)
pub mod delete_aggregation_authorization_output {
    /// A builder for [`DeleteAggregationAuthorizationOutput`](crate::output::DeleteAggregationAuthorizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {}
    impl Builder {
        /// Consumes the builder and constructs a [`DeleteAggregationAuthorizationOutput`](crate::output::DeleteAggregationAuthorizationOutput)
        pub fn build(self) -> crate::output::DeleteAggregationAuthorizationOutput {
            crate::output::DeleteAggregationAuthorizationOutput {}
        }
    }
}
impl DeleteAggregationAuthorizationOutput {
    /// Creates a new builder-style object to manufacture [`DeleteAggregationAuthorizationOutput`](crate::output::DeleteAggregationAuthorizationOutput)
    pub fn builder() -> crate::output::delete_aggregation_authorization_output::Builder {
        crate::output::delete_aggregation_authorization_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BatchGetResourceConfigOutput {
    /// <p>A list that contains the current configuration of one or more resources.</p>
    pub base_configuration_items:
        std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
    /// <p>A list of resource keys that were not processed with the current response. The unprocessesResourceKeys value is in the same form as ResourceKeys, so the value can be directly provided to a subsequent BatchGetResourceConfig operation. If there are no unprocessed resource keys, the response contains an empty unprocessedResourceKeys list. </p>
    pub unprocessed_resource_keys: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
}
impl BatchGetResourceConfigOutput {
    /// <p>A list that contains the current configuration of one or more resources.</p>
    pub fn base_configuration_items(
        &self,
    ) -> std::option::Option<&[crate::model::BaseConfigurationItem]> {
        self.base_configuration_items.as_deref()
    }
    /// <p>A list of resource keys that were not processed with the current response. The unprocessesResourceKeys value is in the same form as ResourceKeys, so the value can be directly provided to a subsequent BatchGetResourceConfig operation. If there are no unprocessed resource keys, the response contains an empty unprocessedResourceKeys list. </p>
    pub fn unprocessed_resource_keys(&self) -> std::option::Option<&[crate::model::ResourceKey]> {
        self.unprocessed_resource_keys.as_deref()
    }
}
impl std::fmt::Debug for BatchGetResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BatchGetResourceConfigOutput");
        formatter.field("base_configuration_items", &self.base_configuration_items);
        formatter.field("unprocessed_resource_keys", &self.unprocessed_resource_keys);
        formatter.finish()
    }
}
/// See [`BatchGetResourceConfigOutput`](crate::output::BatchGetResourceConfigOutput)
pub mod batch_get_resource_config_output {
    /// A builder for [`BatchGetResourceConfigOutput`](crate::output::BatchGetResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) base_configuration_items:
            std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
        pub(crate) unprocessed_resource_keys:
            std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
    }
    impl Builder {
        /// Appends an item to `base_configuration_items`.
        ///
        /// To override the contents of this collection use [`set_base_configuration_items`](Self::set_base_configuration_items).
        ///
        /// <p>A list that contains the current configuration of one or more resources.</p>
        pub fn base_configuration_items(
            mut self,
            input: crate::model::BaseConfigurationItem,
        ) -> Self {
            let mut v = self.base_configuration_items.unwrap_or_default();
            v.push(input);
            self.base_configuration_items = Some(v);
            self
        }
        /// <p>A list that contains the current configuration of one or more resources.</p>
        pub fn set_base_configuration_items(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
        ) -> Self {
            self.base_configuration_items = input;
            self
        }
        /// Appends an item to `unprocessed_resource_keys`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_resource_keys`](Self::set_unprocessed_resource_keys).
        ///
        /// <p>A list of resource keys that were not processed with the current response. The unprocessesResourceKeys value is in the same form as ResourceKeys, so the value can be directly provided to a subsequent BatchGetResourceConfig operation. If there are no unprocessed resource keys, the response contains an empty unprocessedResourceKeys list. </p>
        pub fn unprocessed_resource_keys(mut self, input: crate::model::ResourceKey) -> Self {
            let mut v = self.unprocessed_resource_keys.unwrap_or_default();
            v.push(input);
            self.unprocessed_resource_keys = Some(v);
            self
        }
        /// <p>A list of resource keys that were not processed with the current response. The unprocessesResourceKeys value is in the same form as ResourceKeys, so the value can be directly provided to a subsequent BatchGetResourceConfig operation. If there are no unprocessed resource keys, the response contains an empty unprocessedResourceKeys list. </p>
        pub fn set_unprocessed_resource_keys(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
        ) -> Self {
            self.unprocessed_resource_keys = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchGetResourceConfigOutput`](crate::output::BatchGetResourceConfigOutput)
        pub fn build(self) -> crate::output::BatchGetResourceConfigOutput {
            crate::output::BatchGetResourceConfigOutput {
                base_configuration_items: self.base_configuration_items,
                unprocessed_resource_keys: self.unprocessed_resource_keys,
            }
        }
    }
}
impl BatchGetResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`BatchGetResourceConfigOutput`](crate::output::BatchGetResourceConfigOutput)
    pub fn builder() -> crate::output::batch_get_resource_config_output::Builder {
        crate::output::batch_get_resource_config_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BatchGetAggregateResourceConfigOutput {
    /// <p>A list that contains the current configuration of one or more resources.</p>
    pub base_configuration_items:
        std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
    /// <p>A list of resource identifiers that were not processed with current scope. The list is empty if all the resources are processed.</p>
    pub unprocessed_resource_identifiers:
        std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
}
impl BatchGetAggregateResourceConfigOutput {
    /// <p>A list that contains the current configuration of one or more resources.</p>
    pub fn base_configuration_items(
        &self,
    ) -> std::option::Option<&[crate::model::BaseConfigurationItem]> {
        self.base_configuration_items.as_deref()
    }
    /// <p>A list of resource identifiers that were not processed with current scope. The list is empty if all the resources are processed.</p>
    pub fn unprocessed_resource_identifiers(
        &self,
    ) -> std::option::Option<&[crate::model::AggregateResourceIdentifier]> {
        self.unprocessed_resource_identifiers.as_deref()
    }
}
impl std::fmt::Debug for BatchGetAggregateResourceConfigOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BatchGetAggregateResourceConfigOutput");
        formatter.field("base_configuration_items", &self.base_configuration_items);
        formatter.field(
            "unprocessed_resource_identifiers",
            &self.unprocessed_resource_identifiers,
        );
        formatter.finish()
    }
}
/// See [`BatchGetAggregateResourceConfigOutput`](crate::output::BatchGetAggregateResourceConfigOutput)
pub mod batch_get_aggregate_resource_config_output {
    /// A builder for [`BatchGetAggregateResourceConfigOutput`](crate::output::BatchGetAggregateResourceConfigOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) base_configuration_items:
            std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
        pub(crate) unprocessed_resource_identifiers:
            std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
    }
    impl Builder {
        /// Appends an item to `base_configuration_items`.
        ///
        /// To override the contents of this collection use [`set_base_configuration_items`](Self::set_base_configuration_items).
        ///
        /// <p>A list that contains the current configuration of one or more resources.</p>
        pub fn base_configuration_items(
            mut self,
            input: crate::model::BaseConfigurationItem,
        ) -> Self {
            let mut v = self.base_configuration_items.unwrap_or_default();
            v.push(input);
            self.base_configuration_items = Some(v);
            self
        }
        /// <p>A list that contains the current configuration of one or more resources.</p>
        pub fn set_base_configuration_items(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
        ) -> Self {
            self.base_configuration_items = input;
            self
        }
        /// Appends an item to `unprocessed_resource_identifiers`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_resource_identifiers`](Self::set_unprocessed_resource_identifiers).
        ///
        /// <p>A list of resource identifiers that were not processed with current scope. The list is empty if all the resources are processed.</p>
        pub fn unprocessed_resource_identifiers(
            mut self,
            input: crate::model::AggregateResourceIdentifier,
        ) -> Self {
            let mut v = self.unprocessed_resource_identifiers.unwrap_or_default();
            v.push(input);
            self.unprocessed_resource_identifiers = Some(v);
            self
        }
        /// <p>A list of resource identifiers that were not processed with current scope. The list is empty if all the resources are processed.</p>
        pub fn set_unprocessed_resource_identifiers(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
        ) -> Self {
            self.unprocessed_resource_identifiers = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchGetAggregateResourceConfigOutput`](crate::output::BatchGetAggregateResourceConfigOutput)
        pub fn build(self) -> crate::output::BatchGetAggregateResourceConfigOutput {
            crate::output::BatchGetAggregateResourceConfigOutput {
                base_configuration_items: self.base_configuration_items,
                unprocessed_resource_identifiers: self.unprocessed_resource_identifiers,
            }
        }
    }
}
impl BatchGetAggregateResourceConfigOutput {
    /// Creates a new builder-style object to manufacture [`BatchGetAggregateResourceConfigOutput`](crate::output::BatchGetAggregateResourceConfigOutput)
    pub fn builder() -> crate::output::batch_get_aggregate_resource_config_output::Builder {
        crate::output::batch_get_aggregate_resource_config_output::Builder::default()
    }
}
