#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct UntagResourceOutput {}
pub mod untag_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::UntagResourceOutput {
crate::output::UntagResourceOutput {}
}
}
}
impl UntagResourceOutput {
pub fn builder() -> crate::output::untag_resource_output::Builder {
crate::output::untag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct TagResourceOutput {}
pub mod tag_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::TagResourceOutput {
crate::output::TagResourceOutput {}
}
}
}
impl TagResourceOutput {
pub fn builder() -> crate::output::tag_resource_output::Builder {
crate::output::tag_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StopConfigurationRecorderOutput {}
pub mod stop_configuration_recorder_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::StopConfigurationRecorderOutput {
crate::output::StopConfigurationRecorderOutput {}
}
}
}
impl StopConfigurationRecorderOutput {
pub fn builder() -> crate::output::stop_configuration_recorder_output::Builder {
crate::output::stop_configuration_recorder_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartResourceEvaluationOutput {
#[doc(hidden)]
pub resource_evaluation_id: std::option::Option<std::string::String>,
}
impl StartResourceEvaluationOutput {
pub fn resource_evaluation_id(&self) -> std::option::Option<&str> {
self.resource_evaluation_id.as_deref()
}
}
pub mod start_resource_evaluation_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_evaluation_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn resource_evaluation_id(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_evaluation_id = Some(input.into());
self
}
pub fn set_resource_evaluation_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.resource_evaluation_id = input;
self
}
pub fn build(self) -> crate::output::StartResourceEvaluationOutput {
crate::output::StartResourceEvaluationOutput {
resource_evaluation_id: self.resource_evaluation_id,
}
}
}
}
impl StartResourceEvaluationOutput {
pub fn builder() -> crate::output::start_resource_evaluation_output::Builder {
crate::output::start_resource_evaluation_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartRemediationExecutionOutput {
#[doc(hidden)]
pub failure_message: std::option::Option<std::string::String>,
#[doc(hidden)]
pub failed_items: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
}
impl StartRemediationExecutionOutput {
pub fn failure_message(&self) -> std::option::Option<&str> {
self.failure_message.as_deref()
}
pub fn failed_items(&self) -> std::option::Option<&[crate::model::ResourceKey]> {
self.failed_items.as_deref()
}
}
pub mod start_remediation_execution_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn failure_message(mut self, input: impl Into<std::string::String>) -> Self {
self.failure_message = Some(input.into());
self
}
pub fn set_failure_message(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.failure_message = input;
self
}
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
}
pub fn set_failed_items(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
) -> Self {
self.failed_items = input;
self
}
pub fn build(self) -> crate::output::StartRemediationExecutionOutput {
crate::output::StartRemediationExecutionOutput {
failure_message: self.failure_message,
failed_items: self.failed_items,
}
}
}
}
impl StartRemediationExecutionOutput {
pub fn builder() -> crate::output::start_remediation_execution_output::Builder {
crate::output::start_remediation_execution_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartConfigurationRecorderOutput {}
pub mod start_configuration_recorder_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::StartConfigurationRecorderOutput {
crate::output::StartConfigurationRecorderOutput {}
}
}
}
impl StartConfigurationRecorderOutput {
pub fn builder() -> crate::output::start_configuration_recorder_output::Builder {
crate::output::start_configuration_recorder_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct StartConfigRulesEvaluationOutput {}
pub mod start_config_rules_evaluation_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::StartConfigRulesEvaluationOutput {
crate::output::StartConfigRulesEvaluationOutput {}
}
}
}
impl StartConfigRulesEvaluationOutput {
pub fn builder() -> crate::output::start_config_rules_evaluation_output::Builder {
crate::output::start_config_rules_evaluation_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SelectResourceConfigOutput {
#[doc(hidden)]
pub results: std::option::Option<std::vec::Vec<std::string::String>>,
#[doc(hidden)]
pub query_info: std::option::Option<crate::model::QueryInfo>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl SelectResourceConfigOutput {
pub fn results(&self) -> std::option::Option<&[std::string::String]> {
self.results.as_deref()
}
pub fn query_info(&self) -> std::option::Option<&crate::model::QueryInfo> {
self.query_info.as_ref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod select_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_results(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.results = input;
self
}
pub fn query_info(mut self, input: crate::model::QueryInfo) -> Self {
self.query_info = Some(input);
self
}
pub fn set_query_info(
mut self,
input: std::option::Option<crate::model::QueryInfo>,
) -> Self {
self.query_info = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::select_resource_config_output::Builder {
crate::output::select_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct SelectAggregateResourceConfigOutput {
#[doc(hidden)]
pub results: std::option::Option<std::vec::Vec<std::string::String>>,
#[doc(hidden)]
pub query_info: std::option::Option<crate::model::QueryInfo>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl SelectAggregateResourceConfigOutput {
pub fn results(&self) -> std::option::Option<&[std::string::String]> {
self.results.as_deref()
}
pub fn query_info(&self) -> std::option::Option<&crate::model::QueryInfo> {
self.query_info.as_ref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod select_aggregate_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_results(
mut self,
input: std::option::Option<std::vec::Vec<std::string::String>>,
) -> Self {
self.results = input;
self
}
pub fn query_info(mut self, input: crate::model::QueryInfo) -> Self {
self.query_info = Some(input);
self
}
pub fn set_query_info(
mut self,
input: std::option::Option<crate::model::QueryInfo>,
) -> Self {
self.query_info = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::select_aggregate_resource_config_output::Builder {
crate::output::select_aggregate_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutStoredQueryOutput {
#[doc(hidden)]
pub query_arn: std::option::Option<std::string::String>,
}
impl PutStoredQueryOutput {
pub fn query_arn(&self) -> std::option::Option<&str> {
self.query_arn.as_deref()
}
}
pub mod put_stored_query_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) query_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn query_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.query_arn = Some(input.into());
self
}
pub fn set_query_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
self.query_arn = input;
self
}
pub fn build(self) -> crate::output::PutStoredQueryOutput {
crate::output::PutStoredQueryOutput {
query_arn: self.query_arn,
}
}
}
}
impl PutStoredQueryOutput {
pub fn builder() -> crate::output::put_stored_query_output::Builder {
crate::output::put_stored_query_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutRetentionConfigurationOutput {
#[doc(hidden)]
pub retention_configuration: std::option::Option<crate::model::RetentionConfiguration>,
}
impl PutRetentionConfigurationOutput {
pub fn retention_configuration(
&self,
) -> std::option::Option<&crate::model::RetentionConfiguration> {
self.retention_configuration.as_ref()
}
}
pub mod put_retention_configuration_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) retention_configuration:
std::option::Option<crate::model::RetentionConfiguration>,
}
impl Builder {
pub fn retention_configuration(
mut self,
input: crate::model::RetentionConfiguration,
) -> Self {
self.retention_configuration = Some(input);
self
}
pub fn set_retention_configuration(
mut self,
input: std::option::Option<crate::model::RetentionConfiguration>,
) -> Self {
self.retention_configuration = input;
self
}
pub fn build(self) -> crate::output::PutRetentionConfigurationOutput {
crate::output::PutRetentionConfigurationOutput {
retention_configuration: self.retention_configuration,
}
}
}
}
impl PutRetentionConfigurationOutput {
pub fn builder() -> crate::output::put_retention_configuration_output::Builder {
crate::output::put_retention_configuration_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutResourceConfigOutput {}
pub mod put_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::PutResourceConfigOutput {
crate::output::PutResourceConfigOutput {}
}
}
}
impl PutResourceConfigOutput {
pub fn builder() -> crate::output::put_resource_config_output::Builder {
crate::output::put_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutRemediationExceptionsOutput {
#[doc(hidden)]
pub failed_batches:
std::option::Option<std::vec::Vec<crate::model::FailedRemediationExceptionBatch>>,
}
impl PutRemediationExceptionsOutput {
pub fn failed_batches(
&self,
) -> std::option::Option<&[crate::model::FailedRemediationExceptionBatch]> {
self.failed_batches.as_deref()
}
}
pub mod put_remediation_exceptions_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) failed_batches:
std::option::Option<std::vec::Vec<crate::model::FailedRemediationExceptionBatch>>,
}
impl Builder {
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
}
pub fn set_failed_batches(
mut self,
input: std::option::Option<
std::vec::Vec<crate::model::FailedRemediationExceptionBatch>,
>,
) -> Self {
self.failed_batches = input;
self
}
pub fn build(self) -> crate::output::PutRemediationExceptionsOutput {
crate::output::PutRemediationExceptionsOutput {
failed_batches: self.failed_batches,
}
}
}
}
impl PutRemediationExceptionsOutput {
pub fn builder() -> crate::output::put_remediation_exceptions_output::Builder {
crate::output::put_remediation_exceptions_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutRemediationConfigurationsOutput {
#[doc(hidden)]
pub failed_batches: std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
}
impl PutRemediationConfigurationsOutput {
pub fn failed_batches(&self) -> std::option::Option<&[crate::model::FailedRemediationBatch]> {
self.failed_batches.as_deref()
}
}
pub mod put_remediation_configurations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) failed_batches:
std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
}
impl Builder {
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
}
pub fn set_failed_batches(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::FailedRemediationBatch>>,
) -> Self {
self.failed_batches = input;
self
}
pub fn build(self) -> crate::output::PutRemediationConfigurationsOutput {
crate::output::PutRemediationConfigurationsOutput {
failed_batches: self.failed_batches,
}
}
}
}
impl PutRemediationConfigurationsOutput {
pub fn builder() -> crate::output::put_remediation_configurations_output::Builder {
crate::output::put_remediation_configurations_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutOrganizationConformancePackOutput {
#[doc(hidden)]
pub organization_conformance_pack_arn: std::option::Option<std::string::String>,
}
impl PutOrganizationConformancePackOutput {
pub fn organization_conformance_pack_arn(&self) -> std::option::Option<&str> {
self.organization_conformance_pack_arn.as_deref()
}
}
pub mod put_organization_conformance_pack_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) organization_conformance_pack_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn organization_conformance_pack_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.organization_conformance_pack_arn = Some(input.into());
self
}
pub fn set_organization_conformance_pack_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.organization_conformance_pack_arn = input;
self
}
pub fn build(self) -> crate::output::PutOrganizationConformancePackOutput {
crate::output::PutOrganizationConformancePackOutput {
organization_conformance_pack_arn: self.organization_conformance_pack_arn,
}
}
}
}
impl PutOrganizationConformancePackOutput {
pub fn builder() -> crate::output::put_organization_conformance_pack_output::Builder {
crate::output::put_organization_conformance_pack_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutOrganizationConfigRuleOutput {
#[doc(hidden)]
pub organization_config_rule_arn: std::option::Option<std::string::String>,
}
impl PutOrganizationConfigRuleOutput {
pub fn organization_config_rule_arn(&self) -> std::option::Option<&str> {
self.organization_config_rule_arn.as_deref()
}
}
pub mod put_organization_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) organization_config_rule_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn organization_config_rule_arn(
mut self,
input: impl Into<std::string::String>,
) -> Self {
self.organization_config_rule_arn = Some(input.into());
self
}
pub fn set_organization_config_rule_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.organization_config_rule_arn = input;
self
}
pub fn build(self) -> crate::output::PutOrganizationConfigRuleOutput {
crate::output::PutOrganizationConfigRuleOutput {
organization_config_rule_arn: self.organization_config_rule_arn,
}
}
}
}
impl PutOrganizationConfigRuleOutput {
pub fn builder() -> crate::output::put_organization_config_rule_output::Builder {
crate::output::put_organization_config_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutExternalEvaluationOutput {}
pub mod put_external_evaluation_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::PutExternalEvaluationOutput {
crate::output::PutExternalEvaluationOutput {}
}
}
}
impl PutExternalEvaluationOutput {
pub fn builder() -> crate::output::put_external_evaluation_output::Builder {
crate::output::put_external_evaluation_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutEvaluationsOutput {
#[doc(hidden)]
pub failed_evaluations: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
}
impl PutEvaluationsOutput {
pub fn failed_evaluations(&self) -> std::option::Option<&[crate::model::Evaluation]> {
self.failed_evaluations.as_deref()
}
}
pub mod put_evaluations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) failed_evaluations: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
}
impl Builder {
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
}
pub fn set_failed_evaluations(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Evaluation>>,
) -> Self {
self.failed_evaluations = input;
self
}
pub fn build(self) -> crate::output::PutEvaluationsOutput {
crate::output::PutEvaluationsOutput {
failed_evaluations: self.failed_evaluations,
}
}
}
}
impl PutEvaluationsOutput {
pub fn builder() -> crate::output::put_evaluations_output::Builder {
crate::output::put_evaluations_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutDeliveryChannelOutput {}
pub mod put_delivery_channel_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::PutDeliveryChannelOutput {
crate::output::PutDeliveryChannelOutput {}
}
}
}
impl PutDeliveryChannelOutput {
pub fn builder() -> crate::output::put_delivery_channel_output::Builder {
crate::output::put_delivery_channel_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutConformancePackOutput {
#[doc(hidden)]
pub conformance_pack_arn: std::option::Option<std::string::String>,
}
impl PutConformancePackOutput {
pub fn conformance_pack_arn(&self) -> std::option::Option<&str> {
self.conformance_pack_arn.as_deref()
}
}
pub mod put_conformance_pack_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) conformance_pack_arn: std::option::Option<std::string::String>,
}
impl Builder {
pub fn conformance_pack_arn(mut self, input: impl Into<std::string::String>) -> Self {
self.conformance_pack_arn = Some(input.into());
self
}
pub fn set_conformance_pack_arn(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conformance_pack_arn = input;
self
}
pub fn build(self) -> crate::output::PutConformancePackOutput {
crate::output::PutConformancePackOutput {
conformance_pack_arn: self.conformance_pack_arn,
}
}
}
}
impl PutConformancePackOutput {
pub fn builder() -> crate::output::put_conformance_pack_output::Builder {
crate::output::put_conformance_pack_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutConfigurationRecorderOutput {}
pub mod put_configuration_recorder_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::PutConfigurationRecorderOutput {
crate::output::PutConfigurationRecorderOutput {}
}
}
}
impl PutConfigurationRecorderOutput {
pub fn builder() -> crate::output::put_configuration_recorder_output::Builder {
crate::output::put_configuration_recorder_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutConfigurationAggregatorOutput {
#[doc(hidden)]
pub configuration_aggregator: std::option::Option<crate::model::ConfigurationAggregator>,
}
impl PutConfigurationAggregatorOutput {
pub fn configuration_aggregator(
&self,
) -> std::option::Option<&crate::model::ConfigurationAggregator> {
self.configuration_aggregator.as_ref()
}
}
pub mod put_configuration_aggregator_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) configuration_aggregator:
std::option::Option<crate::model::ConfigurationAggregator>,
}
impl Builder {
pub fn configuration_aggregator(
mut self,
input: crate::model::ConfigurationAggregator,
) -> Self {
self.configuration_aggregator = Some(input);
self
}
pub fn set_configuration_aggregator(
mut self,
input: std::option::Option<crate::model::ConfigurationAggregator>,
) -> Self {
self.configuration_aggregator = input;
self
}
pub fn build(self) -> crate::output::PutConfigurationAggregatorOutput {
crate::output::PutConfigurationAggregatorOutput {
configuration_aggregator: self.configuration_aggregator,
}
}
}
}
impl PutConfigurationAggregatorOutput {
pub fn builder() -> crate::output::put_configuration_aggregator_output::Builder {
crate::output::put_configuration_aggregator_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutConfigRuleOutput {}
pub mod put_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::PutConfigRuleOutput {
crate::output::PutConfigRuleOutput {}
}
}
}
impl PutConfigRuleOutput {
pub fn builder() -> crate::output::put_config_rule_output::Builder {
crate::output::put_config_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct PutAggregationAuthorizationOutput {
#[doc(hidden)]
pub aggregation_authorization: std::option::Option<crate::model::AggregationAuthorization>,
}
impl PutAggregationAuthorizationOutput {
pub fn aggregation_authorization(
&self,
) -> std::option::Option<&crate::model::AggregationAuthorization> {
self.aggregation_authorization.as_ref()
}
}
pub mod put_aggregation_authorization_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) aggregation_authorization:
std::option::Option<crate::model::AggregationAuthorization>,
}
impl Builder {
pub fn aggregation_authorization(
mut self,
input: crate::model::AggregationAuthorization,
) -> Self {
self.aggregation_authorization = Some(input);
self
}
pub fn set_aggregation_authorization(
mut self,
input: std::option::Option<crate::model::AggregationAuthorization>,
) -> Self {
self.aggregation_authorization = input;
self
}
pub fn build(self) -> crate::output::PutAggregationAuthorizationOutput {
crate::output::PutAggregationAuthorizationOutput {
aggregation_authorization: self.aggregation_authorization,
}
}
}
}
impl PutAggregationAuthorizationOutput {
pub fn builder() -> crate::output::put_aggregation_authorization_output::Builder {
crate::output::put_aggregation_authorization_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListTagsForResourceOutput {
#[doc(hidden)]
pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListTagsForResourceOutput {
pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
self.tags.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_tags_for_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_tags(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
) -> Self {
self.tags = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListTagsForResourceOutput {
crate::output::ListTagsForResourceOutput {
tags: self.tags,
next_token: self.next_token,
}
}
}
}
impl ListTagsForResourceOutput {
pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
crate::output::list_tags_for_resource_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListStoredQueriesOutput {
#[doc(hidden)]
pub stored_query_metadata:
std::option::Option<std::vec::Vec<crate::model::StoredQueryMetadata>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListStoredQueriesOutput {
pub fn stored_query_metadata(
&self,
) -> std::option::Option<&[crate::model::StoredQueryMetadata]> {
self.stored_query_metadata.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_stored_queries_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListStoredQueriesOutput {
crate::output::ListStoredQueriesOutput {
stored_query_metadata: self.stored_query_metadata,
next_token: self.next_token,
}
}
}
}
impl ListStoredQueriesOutput {
pub fn builder() -> crate::output::list_stored_queries_output::Builder {
crate::output::list_stored_queries_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListResourceEvaluationsOutput {
#[doc(hidden)]
pub resource_evaluations: std::option::Option<std::vec::Vec<crate::model::ResourceEvaluation>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListResourceEvaluationsOutput {
pub fn resource_evaluations(&self) -> std::option::Option<&[crate::model::ResourceEvaluation]> {
self.resource_evaluations.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_resource_evaluations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_evaluations:
std::option::Option<std::vec::Vec<crate::model::ResourceEvaluation>>,
pub(crate) next_token: std::option::Option<std::string::String>,
}
impl Builder {
pub fn resource_evaluations(mut self, input: crate::model::ResourceEvaluation) -> Self {
let mut v = self.resource_evaluations.unwrap_or_default();
v.push(input);
self.resource_evaluations = Some(v);
self
}
pub fn set_resource_evaluations(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ResourceEvaluation>>,
) -> Self {
self.resource_evaluations = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListResourceEvaluationsOutput {
crate::output::ListResourceEvaluationsOutput {
resource_evaluations: self.resource_evaluations,
next_token: self.next_token,
}
}
}
}
impl ListResourceEvaluationsOutput {
pub fn builder() -> crate::output::list_resource_evaluations_output::Builder {
crate::output::list_resource_evaluations_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListDiscoveredResourcesOutput {
#[doc(hidden)]
pub resource_identifiers: std::option::Option<std::vec::Vec<crate::model::ResourceIdentifier>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListDiscoveredResourcesOutput {
pub fn resource_identifiers(&self) -> std::option::Option<&[crate::model::ResourceIdentifier]> {
self.resource_identifiers.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_discovered_resources_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_resource_identifiers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ResourceIdentifier>>,
) -> Self {
self.resource_identifiers = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListDiscoveredResourcesOutput {
crate::output::ListDiscoveredResourcesOutput {
resource_identifiers: self.resource_identifiers,
next_token: self.next_token,
}
}
}
}
impl ListDiscoveredResourcesOutput {
pub fn builder() -> crate::output::list_discovered_resources_output::Builder {
crate::output::list_discovered_resources_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListConformancePackComplianceScoresOutput {
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
#[doc(hidden)]
pub conformance_pack_compliance_scores:
std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceScore>>,
}
impl ListConformancePackComplianceScoresOutput {
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
pub fn conformance_pack_compliance_scores(
&self,
) -> std::option::Option<&[crate::model::ConformancePackComplianceScore]> {
self.conformance_pack_compliance_scores.as_deref()
}
}
pub mod list_conformance_pack_compliance_scores_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) next_token: std::option::Option<std::string::String>,
pub(crate) conformance_pack_compliance_scores:
std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceScore>>,
}
impl Builder {
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn conformance_pack_compliance_scores(
mut self,
input: crate::model::ConformancePackComplianceScore,
) -> Self {
let mut v = self.conformance_pack_compliance_scores.unwrap_or_default();
v.push(input);
self.conformance_pack_compliance_scores = Some(v);
self
}
pub fn set_conformance_pack_compliance_scores(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceScore>>,
) -> Self {
self.conformance_pack_compliance_scores = input;
self
}
pub fn build(self) -> crate::output::ListConformancePackComplianceScoresOutput {
crate::output::ListConformancePackComplianceScoresOutput {
next_token: self.next_token,
conformance_pack_compliance_scores: self.conformance_pack_compliance_scores,
}
}
}
}
impl ListConformancePackComplianceScoresOutput {
pub fn builder() -> crate::output::list_conformance_pack_compliance_scores_output::Builder {
crate::output::list_conformance_pack_compliance_scores_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct ListAggregateDiscoveredResourcesOutput {
#[doc(hidden)]
pub resource_identifiers:
std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl ListAggregateDiscoveredResourcesOutput {
pub fn resource_identifiers(
&self,
) -> std::option::Option<&[crate::model::AggregateResourceIdentifier]> {
self.resource_identifiers.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod list_aggregate_discovered_resources_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_resource_identifiers(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
) -> Self {
self.resource_identifiers = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::ListAggregateDiscoveredResourcesOutput {
crate::output::ListAggregateDiscoveredResourcesOutput {
resource_identifiers: self.resource_identifiers,
next_token: self.next_token,
}
}
}
}
impl ListAggregateDiscoveredResourcesOutput {
pub fn builder() -> crate::output::list_aggregate_discovered_resources_output::Builder {
crate::output::list_aggregate_discovered_resources_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetStoredQueryOutput {
#[doc(hidden)]
pub stored_query: std::option::Option<crate::model::StoredQuery>,
}
impl GetStoredQueryOutput {
pub fn stored_query(&self) -> std::option::Option<&crate::model::StoredQuery> {
self.stored_query.as_ref()
}
}
pub mod get_stored_query_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) stored_query: std::option::Option<crate::model::StoredQuery>,
}
impl Builder {
pub fn stored_query(mut self, input: crate::model::StoredQuery) -> Self {
self.stored_query = Some(input);
self
}
pub fn set_stored_query(
mut self,
input: std::option::Option<crate::model::StoredQuery>,
) -> Self {
self.stored_query = input;
self
}
pub fn build(self) -> crate::output::GetStoredQueryOutput {
crate::output::GetStoredQueryOutput {
stored_query: self.stored_query,
}
}
}
}
impl GetStoredQueryOutput {
pub fn builder() -> crate::output::get_stored_query_output::Builder {
crate::output::get_stored_query_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetResourceEvaluationSummaryOutput {
#[doc(hidden)]
pub resource_evaluation_id: std::option::Option<std::string::String>,
#[doc(hidden)]
pub evaluation_mode: std::option::Option<crate::model::EvaluationMode>,
#[doc(hidden)]
pub evaluation_status: std::option::Option<crate::model::EvaluationStatus>,
#[doc(hidden)]
pub evaluation_start_timestamp: std::option::Option<aws_smithy_types::DateTime>,
#[doc(hidden)]
pub compliance: std::option::Option<crate::model::ComplianceType>,
#[doc(hidden)]
pub evaluation_context: std::option::Option<crate::model::EvaluationContext>,
#[doc(hidden)]
pub resource_details: std::option::Option<crate::model::ResourceDetails>,
}
impl GetResourceEvaluationSummaryOutput {
pub fn resource_evaluation_id(&self) -> std::option::Option<&str> {
self.resource_evaluation_id.as_deref()
}
pub fn evaluation_mode(&self) -> std::option::Option<&crate::model::EvaluationMode> {
self.evaluation_mode.as_ref()
}
pub fn evaluation_status(&self) -> std::option::Option<&crate::model::EvaluationStatus> {
self.evaluation_status.as_ref()
}
pub fn evaluation_start_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
self.evaluation_start_timestamp.as_ref()
}
pub fn compliance(&self) -> std::option::Option<&crate::model::ComplianceType> {
self.compliance.as_ref()
}
pub fn evaluation_context(&self) -> std::option::Option<&crate::model::EvaluationContext> {
self.evaluation_context.as_ref()
}
pub fn resource_details(&self) -> std::option::Option<&crate::model::ResourceDetails> {
self.resource_details.as_ref()
}
}
pub mod get_resource_evaluation_summary_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) resource_evaluation_id: std::option::Option<std::string::String>,
pub(crate) evaluation_mode: std::option::Option<crate::model::EvaluationMode>,
pub(crate) evaluation_status: std::option::Option<crate::model::EvaluationStatus>,
pub(crate) evaluation_start_timestamp: std::option::Option<aws_smithy_types::DateTime>,
pub(crate) compliance: std::option::Option<crate::model::ComplianceType>,
pub(crate) evaluation_context: std::option::Option<crate::model::EvaluationContext>,
pub(crate) resource_details: std::option::Option<crate::model::ResourceDetails>,
}
impl Builder {
pub fn resource_evaluation_id(mut self, input: impl Into<std::string::String>) -> Self {
self.resource_evaluation_id = Some(input.into());
self
}
pub fn set_resource_evaluation_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.resource_evaluation_id = input;
self
}
pub fn evaluation_mode(mut self, input: crate::model::EvaluationMode) -> Self {
self.evaluation_mode = Some(input);
self
}
pub fn set_evaluation_mode(
mut self,
input: std::option::Option<crate::model::EvaluationMode>,
) -> Self {
self.evaluation_mode = input;
self
}
pub fn evaluation_status(mut self, input: crate::model::EvaluationStatus) -> Self {
self.evaluation_status = Some(input);
self
}
pub fn set_evaluation_status(
mut self,
input: std::option::Option<crate::model::EvaluationStatus>,
) -> Self {
self.evaluation_status = input;
self
}
pub fn evaluation_start_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
self.evaluation_start_timestamp = Some(input);
self
}
pub fn set_evaluation_start_timestamp(
mut self,
input: std::option::Option<aws_smithy_types::DateTime>,
) -> Self {
self.evaluation_start_timestamp = input;
self
}
pub fn compliance(mut self, input: crate::model::ComplianceType) -> Self {
self.compliance = Some(input);
self
}
pub fn set_compliance(
mut self,
input: std::option::Option<crate::model::ComplianceType>,
) -> Self {
self.compliance = input;
self
}
pub fn evaluation_context(mut self, input: crate::model::EvaluationContext) -> Self {
self.evaluation_context = Some(input);
self
}
pub fn set_evaluation_context(
mut self,
input: std::option::Option<crate::model::EvaluationContext>,
) -> Self {
self.evaluation_context = input;
self
}
pub fn resource_details(mut self, input: crate::model::ResourceDetails) -> Self {
self.resource_details = Some(input);
self
}
pub fn set_resource_details(
mut self,
input: std::option::Option<crate::model::ResourceDetails>,
) -> Self {
self.resource_details = input;
self
}
pub fn build(self) -> crate::output::GetResourceEvaluationSummaryOutput {
crate::output::GetResourceEvaluationSummaryOutput {
resource_evaluation_id: self.resource_evaluation_id,
evaluation_mode: self.evaluation_mode,
evaluation_status: self.evaluation_status,
evaluation_start_timestamp: self.evaluation_start_timestamp,
compliance: self.compliance,
evaluation_context: self.evaluation_context,
resource_details: self.resource_details,
}
}
}
}
impl GetResourceEvaluationSummaryOutput {
pub fn builder() -> crate::output::get_resource_evaluation_summary_output::Builder {
crate::output::get_resource_evaluation_summary_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetResourceConfigHistoryOutput {
#[doc(hidden)]
pub configuration_items: std::option::Option<std::vec::Vec<crate::model::ConfigurationItem>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetResourceConfigHistoryOutput {
pub fn configuration_items(&self) -> std::option::Option<&[crate::model::ConfigurationItem]> {
self.configuration_items.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_resource_config_history_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_configuration_items(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ConfigurationItem>>,
) -> Self {
self.configuration_items = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::GetResourceConfigHistoryOutput {
crate::output::GetResourceConfigHistoryOutput {
configuration_items: self.configuration_items,
next_token: self.next_token,
}
}
}
}
impl GetResourceConfigHistoryOutput {
pub fn builder() -> crate::output::get_resource_config_history_output::Builder {
crate::output::get_resource_config_history_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetOrganizationCustomRulePolicyOutput {
#[doc(hidden)]
pub policy_text: std::option::Option<std::string::String>,
}
impl GetOrganizationCustomRulePolicyOutput {
pub fn policy_text(&self) -> std::option::Option<&str> {
self.policy_text.as_deref()
}
}
pub mod get_organization_custom_rule_policy_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) policy_text: std::option::Option<std::string::String>,
}
impl Builder {
pub fn policy_text(mut self, input: impl Into<std::string::String>) -> Self {
self.policy_text = Some(input.into());
self
}
pub fn set_policy_text(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy_text = input;
self
}
pub fn build(self) -> crate::output::GetOrganizationCustomRulePolicyOutput {
crate::output::GetOrganizationCustomRulePolicyOutput {
policy_text: self.policy_text,
}
}
}
}
impl 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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetOrganizationConformancePackDetailedStatusOutput {
#[doc(hidden)]
pub organization_conformance_pack_detailed_statuses:
std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePackDetailedStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetOrganizationConformancePackDetailedStatusOutput {
pub fn organization_conformance_pack_detailed_statuses(
&self,
) -> std::option::Option<&[crate::model::OrganizationConformancePackDetailedStatus]> {
self.organization_conformance_pack_detailed_statuses
.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_organization_conformance_pack_detailed_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetOrganizationConfigRuleDetailedStatusOutput {
#[doc(hidden)]
pub organization_config_rule_detailed_status:
std::option::Option<std::vec::Vec<crate::model::MemberAccountStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetOrganizationConfigRuleDetailedStatusOutput {
pub fn organization_config_rule_detailed_status(
&self,
) -> std::option::Option<&[crate::model::MemberAccountStatus]> {
self.organization_config_rule_detailed_status.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_organization_config_rule_detailed_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetDiscoveredResourceCountsOutput {
#[doc(hidden)]
pub total_discovered_resources: i64,
#[doc(hidden)]
pub resource_counts: std::option::Option<std::vec::Vec<crate::model::ResourceCount>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetDiscoveredResourceCountsOutput {
pub fn total_discovered_resources(&self) -> i64 {
self.total_discovered_resources
}
pub fn resource_counts(&self) -> std::option::Option<&[crate::model::ResourceCount]> {
self.resource_counts.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_discovered_resource_counts_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn total_discovered_resources(mut self, input: i64) -> Self {
self.total_discovered_resources = Some(input);
self
}
pub fn set_total_discovered_resources(mut self, input: std::option::Option<i64>) -> Self {
self.total_discovered_resources = input;
self
}
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
}
pub fn set_resource_counts(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ResourceCount>>,
) -> Self {
self.resource_counts = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::get_discovered_resource_counts_output::Builder {
crate::output::get_discovered_resource_counts_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetCustomRulePolicyOutput {
#[doc(hidden)]
pub policy_text: std::option::Option<std::string::String>,
}
impl GetCustomRulePolicyOutput {
pub fn policy_text(&self) -> std::option::Option<&str> {
self.policy_text.as_deref()
}
}
pub mod get_custom_rule_policy_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) policy_text: std::option::Option<std::string::String>,
}
impl Builder {
pub fn policy_text(mut self, input: impl Into<std::string::String>) -> Self {
self.policy_text = Some(input.into());
self
}
pub fn set_policy_text(mut self, input: std::option::Option<std::string::String>) -> Self {
self.policy_text = input;
self
}
pub fn build(self) -> crate::output::GetCustomRulePolicyOutput {
crate::output::GetCustomRulePolicyOutput {
policy_text: self.policy_text,
}
}
}
}
impl GetCustomRulePolicyOutput {
pub fn builder() -> crate::output::get_custom_rule_policy_output::Builder {
crate::output::get_custom_rule_policy_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetConformancePackComplianceSummaryOutput {
#[doc(hidden)]
pub conformance_pack_compliance_summary_list:
std::option::Option<std::vec::Vec<crate::model::ConformancePackComplianceSummary>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetConformancePackComplianceSummaryOutput {
pub fn conformance_pack_compliance_summary_list(
&self,
) -> std::option::Option<&[crate::model::ConformancePackComplianceSummary]> {
self.conformance_pack_compliance_summary_list.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_conformance_pack_compliance_summary_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetConformancePackComplianceDetailsOutput {
#[doc(hidden)]
pub conformance_pack_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub conformance_pack_rule_evaluation_results:
std::option::Option<std::vec::Vec<crate::model::ConformancePackEvaluationResult>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetConformancePackComplianceDetailsOutput {
pub fn conformance_pack_name(&self) -> std::option::Option<&str> {
self.conformance_pack_name.as_deref()
}
pub fn conformance_pack_rule_evaluation_results(
&self,
) -> std::option::Option<&[crate::model::ConformancePackEvaluationResult]> {
self.conformance_pack_rule_evaluation_results.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_conformance_pack_compliance_details_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn conformance_pack_name(mut self, input: impl Into<std::string::String>) -> Self {
self.conformance_pack_name = Some(input.into());
self
}
pub fn set_conformance_pack_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conformance_pack_name = input;
self
}
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::get_conformance_pack_compliance_details_output::Builder {
crate::output::get_conformance_pack_compliance_details_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetComplianceSummaryByResourceTypeOutput {
#[doc(hidden)]
pub compliance_summaries_by_resource_type:
std::option::Option<std::vec::Vec<crate::model::ComplianceSummaryByResourceType>>,
}
impl GetComplianceSummaryByResourceTypeOutput {
pub fn compliance_summaries_by_resource_type(
&self,
) -> std::option::Option<&[crate::model::ComplianceSummaryByResourceType]> {
self.compliance_summaries_by_resource_type.as_deref()
}
}
pub mod get_compliance_summary_by_resource_type_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) compliance_summaries_by_resource_type:
std::option::Option<std::vec::Vec<crate::model::ComplianceSummaryByResourceType>>,
}
impl Builder {
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
}
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
}
pub fn build(self) -> crate::output::GetComplianceSummaryByResourceTypeOutput {
crate::output::GetComplianceSummaryByResourceTypeOutput {
compliance_summaries_by_resource_type: self.compliance_summaries_by_resource_type,
}
}
}
}
impl 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()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetComplianceSummaryByConfigRuleOutput {
#[doc(hidden)]
pub compliance_summary: std::option::Option<crate::model::ComplianceSummary>,
}
impl GetComplianceSummaryByConfigRuleOutput {
pub fn compliance_summary(&self) -> std::option::Option<&crate::model::ComplianceSummary> {
self.compliance_summary.as_ref()
}
}
pub mod get_compliance_summary_by_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) compliance_summary: std::option::Option<crate::model::ComplianceSummary>,
}
impl Builder {
pub fn compliance_summary(mut self, input: crate::model::ComplianceSummary) -> Self {
self.compliance_summary = Some(input);
self
}
pub fn set_compliance_summary(
mut self,
input: std::option::Option<crate::model::ComplianceSummary>,
) -> Self {
self.compliance_summary = input;
self
}
pub fn build(self) -> crate::output::GetComplianceSummaryByConfigRuleOutput {
crate::output::GetComplianceSummaryByConfigRuleOutput {
compliance_summary: self.compliance_summary,
}
}
}
}
impl 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()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetComplianceDetailsByResourceOutput {
#[doc(hidden)]
pub evaluation_results: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetComplianceDetailsByResourceOutput {
pub fn evaluation_results(&self) -> std::option::Option<&[crate::model::EvaluationResult]> {
self.evaluation_results.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_compliance_details_by_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_evaluation_results(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
) -> Self {
self.evaluation_results = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::GetComplianceDetailsByResourceOutput {
crate::output::GetComplianceDetailsByResourceOutput {
evaluation_results: self.evaluation_results,
next_token: self.next_token,
}
}
}
}
impl GetComplianceDetailsByResourceOutput {
pub fn builder() -> crate::output::get_compliance_details_by_resource_output::Builder {
crate::output::get_compliance_details_by_resource_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetComplianceDetailsByConfigRuleOutput {
#[doc(hidden)]
pub evaluation_results: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetComplianceDetailsByConfigRuleOutput {
pub fn evaluation_results(&self) -> std::option::Option<&[crate::model::EvaluationResult]> {
self.evaluation_results.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_compliance_details_by_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_evaluation_results(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::EvaluationResult>>,
) -> Self {
self.evaluation_results = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::GetComplianceDetailsByConfigRuleOutput {
crate::output::GetComplianceDetailsByConfigRuleOutput {
evaluation_results: self.evaluation_results,
next_token: self.next_token,
}
}
}
}
impl 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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAggregateResourceConfigOutput {
#[doc(hidden)]
pub configuration_item: std::option::Option<crate::model::ConfigurationItem>,
}
impl GetAggregateResourceConfigOutput {
pub fn configuration_item(&self) -> std::option::Option<&crate::model::ConfigurationItem> {
self.configuration_item.as_ref()
}
}
pub mod get_aggregate_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) configuration_item: std::option::Option<crate::model::ConfigurationItem>,
}
impl Builder {
pub fn configuration_item(mut self, input: crate::model::ConfigurationItem) -> Self {
self.configuration_item = Some(input);
self
}
pub fn set_configuration_item(
mut self,
input: std::option::Option<crate::model::ConfigurationItem>,
) -> Self {
self.configuration_item = input;
self
}
pub fn build(self) -> crate::output::GetAggregateResourceConfigOutput {
crate::output::GetAggregateResourceConfigOutput {
configuration_item: self.configuration_item,
}
}
}
}
impl GetAggregateResourceConfigOutput {
pub fn builder() -> crate::output::get_aggregate_resource_config_output::Builder {
crate::output::get_aggregate_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAggregateDiscoveredResourceCountsOutput {
#[doc(hidden)]
pub total_discovered_resources: i64,
#[doc(hidden)]
pub group_by_key: std::option::Option<std::string::String>,
#[doc(hidden)]
pub grouped_resource_counts:
std::option::Option<std::vec::Vec<crate::model::GroupedResourceCount>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateDiscoveredResourceCountsOutput {
pub fn total_discovered_resources(&self) -> i64 {
self.total_discovered_resources
}
pub fn group_by_key(&self) -> std::option::Option<&str> {
self.group_by_key.as_deref()
}
pub fn grouped_resource_counts(
&self,
) -> std::option::Option<&[crate::model::GroupedResourceCount]> {
self.grouped_resource_counts.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_aggregate_discovered_resource_counts_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn total_discovered_resources(mut self, input: i64) -> Self {
self.total_discovered_resources = Some(input);
self
}
pub fn set_total_discovered_resources(mut self, input: std::option::Option<i64>) -> Self {
self.total_discovered_resources = input;
self
}
pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
self.group_by_key = Some(input.into());
self
}
pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_by_key = input;
self
}
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAggregateConformancePackComplianceSummaryOutput {
#[doc(hidden)]
pub aggregate_conformance_pack_compliance_summaries:
std::option::Option<std::vec::Vec<crate::model::AggregateConformancePackComplianceSummary>>,
#[doc(hidden)]
pub group_by_key: std::option::Option<std::string::String>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateConformancePackComplianceSummaryOutput {
pub fn aggregate_conformance_pack_compliance_summaries(
&self,
) -> std::option::Option<&[crate::model::AggregateConformancePackComplianceSummary]> {
self.aggregate_conformance_pack_compliance_summaries
.as_deref()
}
pub fn group_by_key(&self) -> std::option::Option<&str> {
self.group_by_key.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_aggregate_conformance_pack_compliance_summary_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
self.group_by_key = Some(input.into());
self
}
pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_by_key = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAggregateConfigRuleComplianceSummaryOutput {
#[doc(hidden)]
pub group_by_key: std::option::Option<std::string::String>,
#[doc(hidden)]
pub aggregate_compliance_counts:
std::option::Option<std::vec::Vec<crate::model::AggregateComplianceCount>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateConfigRuleComplianceSummaryOutput {
pub fn group_by_key(&self) -> std::option::Option<&str> {
self.group_by_key.as_deref()
}
pub fn aggregate_compliance_counts(
&self,
) -> std::option::Option<&[crate::model::AggregateComplianceCount]> {
self.aggregate_compliance_counts.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_aggregate_config_rule_compliance_summary_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn group_by_key(mut self, input: impl Into<std::string::String>) -> Self {
self.group_by_key = Some(input.into());
self
}
pub fn set_group_by_key(mut self, input: std::option::Option<std::string::String>) -> Self {
self.group_by_key = input;
self
}
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct GetAggregateComplianceDetailsByConfigRuleOutput {
#[doc(hidden)]
pub aggregate_evaluation_results:
std::option::Option<std::vec::Vec<crate::model::AggregateEvaluationResult>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl GetAggregateComplianceDetailsByConfigRuleOutput {
pub fn aggregate_evaluation_results(
&self,
) -> std::option::Option<&[crate::model::AggregateEvaluationResult]> {
self.aggregate_evaluation_results.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod get_aggregate_compliance_details_by_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::GetAggregateComplianceDetailsByConfigRuleOutput {
crate::output::GetAggregateComplianceDetailsByConfigRuleOutput {
aggregate_evaluation_results: self.aggregate_evaluation_results,
next_token: self.next_token,
}
}
}
}
impl 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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeRetentionConfigurationsOutput {
#[doc(hidden)]
pub retention_configurations:
std::option::Option<std::vec::Vec<crate::model::RetentionConfiguration>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRetentionConfigurationsOutput {
pub fn retention_configurations(
&self,
) -> std::option::Option<&[crate::model::RetentionConfiguration]> {
self.retention_configurations.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_retention_configurations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_retention_configurations(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::RetentionConfiguration>>,
) -> Self {
self.retention_configurations = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeRetentionConfigurationsOutput {
crate::output::DescribeRetentionConfigurationsOutput {
retention_configurations: self.retention_configurations,
next_token: self.next_token,
}
}
}
}
impl DescribeRetentionConfigurationsOutput {
pub fn builder() -> crate::output::describe_retention_configurations_output::Builder {
crate::output::describe_retention_configurations_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeRemediationExecutionStatusOutput {
#[doc(hidden)]
pub remediation_execution_statuses:
std::option::Option<std::vec::Vec<crate::model::RemediationExecutionStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRemediationExecutionStatusOutput {
pub fn remediation_execution_statuses(
&self,
) -> std::option::Option<&[crate::model::RemediationExecutionStatus]> {
self.remediation_execution_statuses.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_remediation_execution_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeRemediationExecutionStatusOutput {
crate::output::DescribeRemediationExecutionStatusOutput {
remediation_execution_statuses: self.remediation_execution_statuses,
next_token: self.next_token,
}
}
}
}
impl DescribeRemediationExecutionStatusOutput {
pub fn builder() -> crate::output::describe_remediation_execution_status_output::Builder {
crate::output::describe_remediation_execution_status_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeRemediationExceptionsOutput {
#[doc(hidden)]
pub remediation_exceptions:
std::option::Option<std::vec::Vec<crate::model::RemediationException>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeRemediationExceptionsOutput {
pub fn remediation_exceptions(
&self,
) -> std::option::Option<&[crate::model::RemediationException]> {
self.remediation_exceptions.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_remediation_exceptions_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_remediation_exceptions(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::RemediationException>>,
) -> Self {
self.remediation_exceptions = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeRemediationExceptionsOutput {
crate::output::DescribeRemediationExceptionsOutput {
remediation_exceptions: self.remediation_exceptions,
next_token: self.next_token,
}
}
}
}
impl DescribeRemediationExceptionsOutput {
pub fn builder() -> crate::output::describe_remediation_exceptions_output::Builder {
crate::output::describe_remediation_exceptions_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeRemediationConfigurationsOutput {
#[doc(hidden)]
pub remediation_configurations:
std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
}
impl DescribeRemediationConfigurationsOutput {
pub fn remediation_configurations(
&self,
) -> std::option::Option<&[crate::model::RemediationConfiguration]> {
self.remediation_configurations.as_deref()
}
}
pub mod describe_remediation_configurations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) remediation_configurations:
std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
}
impl Builder {
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
}
pub fn set_remediation_configurations(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::RemediationConfiguration>>,
) -> Self {
self.remediation_configurations = input;
self
}
pub fn build(self) -> crate::output::DescribeRemediationConfigurationsOutput {
crate::output::DescribeRemediationConfigurationsOutput {
remediation_configurations: self.remediation_configurations,
}
}
}
}
impl DescribeRemediationConfigurationsOutput {
pub fn builder() -> crate::output::describe_remediation_configurations_output::Builder {
crate::output::describe_remediation_configurations_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribePendingAggregationRequestsOutput {
#[doc(hidden)]
pub pending_aggregation_requests:
std::option::Option<std::vec::Vec<crate::model::PendingAggregationRequest>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribePendingAggregationRequestsOutput {
pub fn pending_aggregation_requests(
&self,
) -> std::option::Option<&[crate::model::PendingAggregationRequest]> {
self.pending_aggregation_requests.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_pending_aggregation_requests_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribePendingAggregationRequestsOutput {
crate::output::DescribePendingAggregationRequestsOutput {
pending_aggregation_requests: self.pending_aggregation_requests,
next_token: self.next_token,
}
}
}
}
impl DescribePendingAggregationRequestsOutput {
pub fn builder() -> crate::output::describe_pending_aggregation_requests_output::Builder {
crate::output::describe_pending_aggregation_requests_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeOrganizationConformancePackStatusesOutput {
#[doc(hidden)]
pub organization_conformance_pack_statuses:
std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePackStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConformancePackStatusesOutput {
pub fn organization_conformance_pack_statuses(
&self,
) -> std::option::Option<&[crate::model::OrganizationConformancePackStatus]> {
self.organization_conformance_pack_statuses.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_organization_conformance_pack_statuses_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeOrganizationConformancePacksOutput {
#[doc(hidden)]
pub organization_conformance_packs:
std::option::Option<std::vec::Vec<crate::model::OrganizationConformancePack>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConformancePacksOutput {
pub fn organization_conformance_packs(
&self,
) -> std::option::Option<&[crate::model::OrganizationConformancePack]> {
self.organization_conformance_packs.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_organization_conformance_packs_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeOrganizationConformancePacksOutput {
crate::output::DescribeOrganizationConformancePacksOutput {
organization_conformance_packs: self.organization_conformance_packs,
next_token: self.next_token,
}
}
}
}
impl DescribeOrganizationConformancePacksOutput {
pub fn builder() -> crate::output::describe_organization_conformance_packs_output::Builder {
crate::output::describe_organization_conformance_packs_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeOrganizationConfigRuleStatusesOutput {
#[doc(hidden)]
pub organization_config_rule_statuses:
std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRuleStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConfigRuleStatusesOutput {
pub fn organization_config_rule_statuses(
&self,
) -> std::option::Option<&[crate::model::OrganizationConfigRuleStatus]> {
self.organization_config_rule_statuses.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_organization_config_rule_statuses_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeOrganizationConfigRulesOutput {
#[doc(hidden)]
pub organization_config_rules:
std::option::Option<std::vec::Vec<crate::model::OrganizationConfigRule>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeOrganizationConfigRulesOutput {
pub fn organization_config_rules(
&self,
) -> std::option::Option<&[crate::model::OrganizationConfigRule]> {
self.organization_config_rules.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_organization_config_rules_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeOrganizationConfigRulesOutput {
crate::output::DescribeOrganizationConfigRulesOutput {
organization_config_rules: self.organization_config_rules,
next_token: self.next_token,
}
}
}
}
impl DescribeOrganizationConfigRulesOutput {
pub fn builder() -> crate::output::describe_organization_config_rules_output::Builder {
crate::output::describe_organization_config_rules_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeDeliveryChannelStatusOutput {
#[doc(hidden)]
pub delivery_channels_status:
std::option::Option<std::vec::Vec<crate::model::DeliveryChannelStatus>>,
}
impl DescribeDeliveryChannelStatusOutput {
pub fn delivery_channels_status(
&self,
) -> std::option::Option<&[crate::model::DeliveryChannelStatus]> {
self.delivery_channels_status.as_deref()
}
}
pub mod describe_delivery_channel_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) delivery_channels_status:
std::option::Option<std::vec::Vec<crate::model::DeliveryChannelStatus>>,
}
impl Builder {
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
}
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
}
pub fn build(self) -> crate::output::DescribeDeliveryChannelStatusOutput {
crate::output::DescribeDeliveryChannelStatusOutput {
delivery_channels_status: self.delivery_channels_status,
}
}
}
}
impl DescribeDeliveryChannelStatusOutput {
pub fn builder() -> crate::output::describe_delivery_channel_status_output::Builder {
crate::output::describe_delivery_channel_status_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeDeliveryChannelsOutput {
#[doc(hidden)]
pub delivery_channels: std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
}
impl DescribeDeliveryChannelsOutput {
pub fn delivery_channels(&self) -> std::option::Option<&[crate::model::DeliveryChannel]> {
self.delivery_channels.as_deref()
}
}
pub mod describe_delivery_channels_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) delivery_channels:
std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
}
impl Builder {
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
}
pub fn set_delivery_channels(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::DeliveryChannel>>,
) -> Self {
self.delivery_channels = input;
self
}
pub fn build(self) -> crate::output::DescribeDeliveryChannelsOutput {
crate::output::DescribeDeliveryChannelsOutput {
delivery_channels: self.delivery_channels,
}
}
}
}
impl DescribeDeliveryChannelsOutput {
pub fn builder() -> crate::output::describe_delivery_channels_output::Builder {
crate::output::describe_delivery_channels_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConformancePackStatusOutput {
#[doc(hidden)]
pub conformance_pack_status_details:
std::option::Option<std::vec::Vec<crate::model::ConformancePackStatusDetail>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePackStatusOutput {
pub fn conformance_pack_status_details(
&self,
) -> std::option::Option<&[crate::model::ConformancePackStatusDetail]> {
self.conformance_pack_status_details.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_conformance_pack_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::describe_conformance_pack_status_output::Builder {
crate::output::describe_conformance_pack_status_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConformancePacksOutput {
#[doc(hidden)]
pub conformance_pack_details:
std::option::Option<std::vec::Vec<crate::model::ConformancePackDetail>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePacksOutput {
pub fn conformance_pack_details(
&self,
) -> std::option::Option<&[crate::model::ConformancePackDetail]> {
self.conformance_pack_details.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_conformance_packs_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeConformancePacksOutput {
crate::output::DescribeConformancePacksOutput {
conformance_pack_details: self.conformance_pack_details,
next_token: self.next_token,
}
}
}
}
impl DescribeConformancePacksOutput {
pub fn builder() -> crate::output::describe_conformance_packs_output::Builder {
crate::output::describe_conformance_packs_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConformancePackComplianceOutput {
#[doc(hidden)]
pub conformance_pack_name: std::option::Option<std::string::String>,
#[doc(hidden)]
pub conformance_pack_rule_compliance_list:
std::option::Option<std::vec::Vec<crate::model::ConformancePackRuleCompliance>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConformancePackComplianceOutput {
pub fn conformance_pack_name(&self) -> std::option::Option<&str> {
self.conformance_pack_name.as_deref()
}
pub fn conformance_pack_rule_compliance_list(
&self,
) -> std::option::Option<&[crate::model::ConformancePackRuleCompliance]> {
self.conformance_pack_rule_compliance_list.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_conformance_pack_compliance_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
pub fn conformance_pack_name(mut self, input: impl Into<std::string::String>) -> Self {
self.conformance_pack_name = Some(input.into());
self
}
pub fn set_conformance_pack_name(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.conformance_pack_name = input;
self
}
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::describe_conformance_pack_compliance_output::Builder {
crate::output::describe_conformance_pack_compliance_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigurationRecorderStatusOutput {
#[doc(hidden)]
pub configuration_recorders_status:
std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorderStatus>>,
}
impl DescribeConfigurationRecorderStatusOutput {
pub fn configuration_recorders_status(
&self,
) -> std::option::Option<&[crate::model::ConfigurationRecorderStatus]> {
self.configuration_recorders_status.as_deref()
}
}
pub mod describe_configuration_recorder_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) configuration_recorders_status:
std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorderStatus>>,
}
impl Builder {
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
}
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
}
pub fn build(self) -> crate::output::DescribeConfigurationRecorderStatusOutput {
crate::output::DescribeConfigurationRecorderStatusOutput {
configuration_recorders_status: self.configuration_recorders_status,
}
}
}
}
impl DescribeConfigurationRecorderStatusOutput {
pub fn builder() -> crate::output::describe_configuration_recorder_status_output::Builder {
crate::output::describe_configuration_recorder_status_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigurationRecordersOutput {
#[doc(hidden)]
pub configuration_recorders:
std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
}
impl DescribeConfigurationRecordersOutput {
pub fn configuration_recorders(
&self,
) -> std::option::Option<&[crate::model::ConfigurationRecorder]> {
self.configuration_recorders.as_deref()
}
}
pub mod describe_configuration_recorders_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) configuration_recorders:
std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
}
impl Builder {
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
}
pub fn set_configuration_recorders(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ConfigurationRecorder>>,
) -> Self {
self.configuration_recorders = input;
self
}
pub fn build(self) -> crate::output::DescribeConfigurationRecordersOutput {
crate::output::DescribeConfigurationRecordersOutput {
configuration_recorders: self.configuration_recorders,
}
}
}
}
impl DescribeConfigurationRecordersOutput {
pub fn builder() -> crate::output::describe_configuration_recorders_output::Builder {
crate::output::describe_configuration_recorders_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigurationAggregatorSourcesStatusOutput {
#[doc(hidden)]
pub aggregated_source_status_list:
std::option::Option<std::vec::Vec<crate::model::AggregatedSourceStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigurationAggregatorSourcesStatusOutput {
pub fn aggregated_source_status_list(
&self,
) -> std::option::Option<&[crate::model::AggregatedSourceStatus]> {
self.aggregated_source_status_list.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_configuration_aggregator_sources_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigurationAggregatorsOutput {
#[doc(hidden)]
pub configuration_aggregators:
std::option::Option<std::vec::Vec<crate::model::ConfigurationAggregator>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigurationAggregatorsOutput {
pub fn configuration_aggregators(
&self,
) -> std::option::Option<&[crate::model::ConfigurationAggregator]> {
self.configuration_aggregators.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_configuration_aggregators_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_configuration_aggregators(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ConfigurationAggregator>>,
) -> Self {
self.configuration_aggregators = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeConfigurationAggregatorsOutput {
crate::output::DescribeConfigurationAggregatorsOutput {
configuration_aggregators: self.configuration_aggregators,
next_token: self.next_token,
}
}
}
}
impl DescribeConfigurationAggregatorsOutput {
pub fn builder() -> crate::output::describe_configuration_aggregators_output::Builder {
crate::output::describe_configuration_aggregators_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigRulesOutput {
#[doc(hidden)]
pub config_rules: std::option::Option<std::vec::Vec<crate::model::ConfigRule>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigRulesOutput {
pub fn config_rules(&self) -> std::option::Option<&[crate::model::ConfigRule]> {
self.config_rules.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_config_rules_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_config_rules(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::ConfigRule>>,
) -> Self {
self.config_rules = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeConfigRulesOutput {
crate::output::DescribeConfigRulesOutput {
config_rules: self.config_rules,
next_token: self.next_token,
}
}
}
}
impl DescribeConfigRulesOutput {
pub fn builder() -> crate::output::describe_config_rules_output::Builder {
crate::output::describe_config_rules_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeConfigRuleEvaluationStatusOutput {
#[doc(hidden)]
pub config_rules_evaluation_status:
std::option::Option<std::vec::Vec<crate::model::ConfigRuleEvaluationStatus>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeConfigRuleEvaluationStatusOutput {
pub fn config_rules_evaluation_status(
&self,
) -> std::option::Option<&[crate::model::ConfigRuleEvaluationStatus]> {
self.config_rules_evaluation_status.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_config_rule_evaluation_status_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::describe_config_rule_evaluation_status_output::Builder {
crate::output::describe_config_rule_evaluation_status_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeComplianceByResourceOutput {
#[doc(hidden)]
pub compliance_by_resources:
std::option::Option<std::vec::Vec<crate::model::ComplianceByResource>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeComplianceByResourceOutput {
pub fn compliance_by_resources(
&self,
) -> std::option::Option<&[crate::model::ComplianceByResource]> {
self.compliance_by_resources.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_compliance_by_resource_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeComplianceByResourceOutput {
crate::output::DescribeComplianceByResourceOutput {
compliance_by_resources: self.compliance_by_resources,
next_token: self.next_token,
}
}
}
}
impl DescribeComplianceByResourceOutput {
pub fn builder() -> crate::output::describe_compliance_by_resource_output::Builder {
crate::output::describe_compliance_by_resource_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeComplianceByConfigRuleOutput {
#[doc(hidden)]
pub compliance_by_config_rules:
std::option::Option<std::vec::Vec<crate::model::ComplianceByConfigRule>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeComplianceByConfigRuleOutput {
pub fn compliance_by_config_rules(
&self,
) -> std::option::Option<&[crate::model::ComplianceByConfigRule]> {
self.compliance_by_config_rules.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_compliance_by_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeAggregationAuthorizationsOutput {
#[doc(hidden)]
pub aggregation_authorizations:
std::option::Option<std::vec::Vec<crate::model::AggregationAuthorization>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregationAuthorizationsOutput {
pub fn aggregation_authorizations(
&self,
) -> std::option::Option<&[crate::model::AggregationAuthorization]> {
self.aggregation_authorizations.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_aggregation_authorizations_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
pub fn set_aggregation_authorizations(
mut self,
input: std::option::Option<std::vec::Vec<crate::model::AggregationAuthorization>>,
) -> Self {
self.aggregation_authorizations = input;
self
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
pub fn build(self) -> crate::output::DescribeAggregationAuthorizationsOutput {
crate::output::DescribeAggregationAuthorizationsOutput {
aggregation_authorizations: self.aggregation_authorizations,
next_token: self.next_token,
}
}
}
}
impl DescribeAggregationAuthorizationsOutput {
pub fn builder() -> crate::output::describe_aggregation_authorizations_output::Builder {
crate::output::describe_aggregation_authorizations_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeAggregateComplianceByConformancePacksOutput {
#[doc(hidden)]
pub aggregate_compliance_by_conformance_packs:
std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConformancePack>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregateComplianceByConformancePacksOutput {
pub fn aggregate_compliance_by_conformance_packs(
&self,
) -> std::option::Option<&[crate::model::AggregateComplianceByConformancePack]> {
self.aggregate_compliance_by_conformance_packs.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_aggregate_compliance_by_conformance_packs_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
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)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DescribeAggregateComplianceByConfigRulesOutput {
#[doc(hidden)]
pub aggregate_compliance_by_config_rules:
std::option::Option<std::vec::Vec<crate::model::AggregateComplianceByConfigRule>>,
#[doc(hidden)]
pub next_token: std::option::Option<std::string::String>,
}
impl DescribeAggregateComplianceByConfigRulesOutput {
pub fn aggregate_compliance_by_config_rules(
&self,
) -> std::option::Option<&[crate::model::AggregateComplianceByConfigRule]> {
self.aggregate_compliance_by_config_rules.as_deref()
}
pub fn next_token(&self) -> std::option::Option<&str> {
self.next_token.as_deref()
}
}
pub mod describe_aggregate_compliance_by_config_rules_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
self.next_token = Some(input.into());
self
}
pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
self.next_token = input;
self
}
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 {
pub fn builder() -> crate::output::describe_aggregate_compliance_by_config_rules_output::Builder
{
crate::output::describe_aggregate_compliance_by_config_rules_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeliverConfigSnapshotOutput {
#[doc(hidden)]
pub config_snapshot_id: std::option::Option<std::string::String>,
}
impl DeliverConfigSnapshotOutput {
pub fn config_snapshot_id(&self) -> std::option::Option<&str> {
self.config_snapshot_id.as_deref()
}
}
pub mod deliver_config_snapshot_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) config_snapshot_id: std::option::Option<std::string::String>,
}
impl Builder {
pub fn config_snapshot_id(mut self, input: impl Into<std::string::String>) -> Self {
self.config_snapshot_id = Some(input.into());
self
}
pub fn set_config_snapshot_id(
mut self,
input: std::option::Option<std::string::String>,
) -> Self {
self.config_snapshot_id = input;
self
}
pub fn build(self) -> crate::output::DeliverConfigSnapshotOutput {
crate::output::DeliverConfigSnapshotOutput {
config_snapshot_id: self.config_snapshot_id,
}
}
}
}
impl DeliverConfigSnapshotOutput {
pub fn builder() -> crate::output::deliver_config_snapshot_output::Builder {
crate::output::deliver_config_snapshot_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteStoredQueryOutput {}
pub mod delete_stored_query_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteStoredQueryOutput {
crate::output::DeleteStoredQueryOutput {}
}
}
}
impl DeleteStoredQueryOutput {
pub fn builder() -> crate::output::delete_stored_query_output::Builder {
crate::output::delete_stored_query_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRetentionConfigurationOutput {}
pub mod delete_retention_configuration_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteRetentionConfigurationOutput {
crate::output::DeleteRetentionConfigurationOutput {}
}
}
}
impl DeleteRetentionConfigurationOutput {
pub fn builder() -> crate::output::delete_retention_configuration_output::Builder {
crate::output::delete_retention_configuration_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteResourceConfigOutput {}
pub mod delete_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteResourceConfigOutput {
crate::output::DeleteResourceConfigOutput {}
}
}
}
impl DeleteResourceConfigOutput {
pub fn builder() -> crate::output::delete_resource_config_output::Builder {
crate::output::delete_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRemediationExceptionsOutput {
#[doc(hidden)]
pub failed_batches:
std::option::Option<std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>>,
}
impl DeleteRemediationExceptionsOutput {
pub fn failed_batches(
&self,
) -> std::option::Option<&[crate::model::FailedDeleteRemediationExceptionsBatch]> {
self.failed_batches.as_deref()
}
}
pub mod delete_remediation_exceptions_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {
pub(crate) failed_batches: std::option::Option<
std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>,
>,
}
impl Builder {
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
}
pub fn set_failed_batches(
mut self,
input: std::option::Option<
std::vec::Vec<crate::model::FailedDeleteRemediationExceptionsBatch>,
>,
) -> Self {
self.failed_batches = input;
self
}
pub fn build(self) -> crate::output::DeleteRemediationExceptionsOutput {
crate::output::DeleteRemediationExceptionsOutput {
failed_batches: self.failed_batches,
}
}
}
}
impl DeleteRemediationExceptionsOutput {
pub fn builder() -> crate::output::delete_remediation_exceptions_output::Builder {
crate::output::delete_remediation_exceptions_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteRemediationConfigurationOutput {}
pub mod delete_remediation_configuration_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteRemediationConfigurationOutput {
crate::output::DeleteRemediationConfigurationOutput {}
}
}
}
impl DeleteRemediationConfigurationOutput {
pub fn builder() -> crate::output::delete_remediation_configuration_output::Builder {
crate::output::delete_remediation_configuration_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeletePendingAggregationRequestOutput {}
pub mod delete_pending_aggregation_request_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeletePendingAggregationRequestOutput {
crate::output::DeletePendingAggregationRequestOutput {}
}
}
}
impl DeletePendingAggregationRequestOutput {
pub fn builder() -> crate::output::delete_pending_aggregation_request_output::Builder {
crate::output::delete_pending_aggregation_request_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteOrganizationConformancePackOutput {}
pub mod delete_organization_conformance_pack_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteOrganizationConformancePackOutput {
crate::output::DeleteOrganizationConformancePackOutput {}
}
}
}
impl DeleteOrganizationConformancePackOutput {
pub fn builder() -> crate::output::delete_organization_conformance_pack_output::Builder {
crate::output::delete_organization_conformance_pack_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteOrganizationConfigRuleOutput {}
pub mod delete_organization_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteOrganizationConfigRuleOutput {
crate::output::DeleteOrganizationConfigRuleOutput {}
}
}
}
impl DeleteOrganizationConfigRuleOutput {
pub fn builder() -> crate::output::delete_organization_config_rule_output::Builder {
crate::output::delete_organization_config_rule_output::Builder::default()
}
}
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteEvaluationResultsOutput {}
pub mod delete_evaluation_results_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteEvaluationResultsOutput {
crate::output::DeleteEvaluationResultsOutput {}
}
}
}
impl DeleteEvaluationResultsOutput {
pub fn builder() -> crate::output::delete_evaluation_results_output::Builder {
crate::output::delete_evaluation_results_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteDeliveryChannelOutput {}
pub mod delete_delivery_channel_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteDeliveryChannelOutput {
crate::output::DeleteDeliveryChannelOutput {}
}
}
}
impl DeleteDeliveryChannelOutput {
pub fn builder() -> crate::output::delete_delivery_channel_output::Builder {
crate::output::delete_delivery_channel_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConformancePackOutput {}
pub mod delete_conformance_pack_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteConformancePackOutput {
crate::output::DeleteConformancePackOutput {}
}
}
}
impl DeleteConformancePackOutput {
pub fn builder() -> crate::output::delete_conformance_pack_output::Builder {
crate::output::delete_conformance_pack_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConfigurationRecorderOutput {}
pub mod delete_configuration_recorder_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteConfigurationRecorderOutput {
crate::output::DeleteConfigurationRecorderOutput {}
}
}
}
impl DeleteConfigurationRecorderOutput {
pub fn builder() -> crate::output::delete_configuration_recorder_output::Builder {
crate::output::delete_configuration_recorder_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConfigurationAggregatorOutput {}
pub mod delete_configuration_aggregator_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteConfigurationAggregatorOutput {
crate::output::DeleteConfigurationAggregatorOutput {}
}
}
}
impl DeleteConfigurationAggregatorOutput {
pub fn builder() -> crate::output::delete_configuration_aggregator_output::Builder {
crate::output::delete_configuration_aggregator_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteConfigRuleOutput {}
pub mod delete_config_rule_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteConfigRuleOutput {
crate::output::DeleteConfigRuleOutput {}
}
}
}
impl DeleteConfigRuleOutput {
pub fn builder() -> crate::output::delete_config_rule_output::Builder {
crate::output::delete_config_rule_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct DeleteAggregationAuthorizationOutput {}
pub mod delete_aggregation_authorization_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, std::fmt::Debug)]
pub struct Builder {}
impl Builder {
pub fn build(self) -> crate::output::DeleteAggregationAuthorizationOutput {
crate::output::DeleteAggregationAuthorizationOutput {}
}
}
}
impl DeleteAggregationAuthorizationOutput {
pub fn builder() -> crate::output::delete_aggregation_authorization_output::Builder {
crate::output::delete_aggregation_authorization_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetResourceConfigOutput {
#[doc(hidden)]
pub base_configuration_items:
std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
#[doc(hidden)]
pub unprocessed_resource_keys: std::option::Option<std::vec::Vec<crate::model::ResourceKey>>,
}
impl BatchGetResourceConfigOutput {
pub fn base_configuration_items(
&self,
) -> std::option::Option<&[crate::model::BaseConfigurationItem]> {
self.base_configuration_items.as_deref()
}
pub fn unprocessed_resource_keys(&self) -> std::option::Option<&[crate::model::ResourceKey]> {
self.unprocessed_resource_keys.as_deref()
}
}
pub mod batch_get_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
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
}
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
}
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 {
pub fn builder() -> crate::output::batch_get_resource_config_output::Builder {
crate::output::batch_get_resource_config_output::Builder::default()
}
}
#[allow(missing_docs)] #[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
pub struct BatchGetAggregateResourceConfigOutput {
#[doc(hidden)]
pub base_configuration_items:
std::option::Option<std::vec::Vec<crate::model::BaseConfigurationItem>>,
#[doc(hidden)]
pub unprocessed_resource_identifiers:
std::option::Option<std::vec::Vec<crate::model::AggregateResourceIdentifier>>,
}
impl BatchGetAggregateResourceConfigOutput {
pub fn base_configuration_items(
&self,
) -> std::option::Option<&[crate::model::BaseConfigurationItem]> {
self.base_configuration_items.as_deref()
}
pub fn unprocessed_resource_identifiers(
&self,
) -> std::option::Option<&[crate::model::AggregateResourceIdentifier]> {
self.unprocessed_resource_identifiers.as_deref()
}
}
pub mod batch_get_aggregate_resource_config_output {
#[derive(std::clone::Clone, std::cmp::PartialEq, std::default::Default, 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 {
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
}
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
}
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
}
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
}
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 {
pub fn builder() -> crate::output::batch_get_aggregate_resource_config_output::Builder {
crate::output::batch_get_aggregate_resource_config_output::Builder::default()
}
}