aws-sdk-securityhub 0.0.22-alpha

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>The tags associated with a resource.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags associated with a resource.</p>
        pub fn tags(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.tags.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.tags = Some(hash_map);
            self
        }
        /// <p>The tags associated with a resource.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput { tags: self.tags }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListOrganizationAdminAccountsOutput {
    /// <p>The list of Security Hub administrator accounts.</p>
    pub admin_accounts: std::option::Option<std::vec::Vec<crate::model::AdminAccount>>,
    /// <p>The pagination token to use to request the next page of results.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListOrganizationAdminAccountsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListOrganizationAdminAccountsOutput");
        formatter.field("admin_accounts", &self.admin_accounts);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListOrganizationAdminAccountsOutput`](crate::output::ListOrganizationAdminAccountsOutput)
pub mod list_organization_admin_accounts_output {
    /// A builder for [`ListOrganizationAdminAccountsOutput`](crate::output::ListOrganizationAdminAccountsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) admin_accounts: std::option::Option<std::vec::Vec<crate::model::AdminAccount>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `admin_accounts`.
        ///
        /// To override the contents of this collection use [`set_admin_accounts`](Self::set_admin_accounts).
        ///
        /// <p>The list of Security Hub administrator accounts.</p>
        pub fn admin_accounts(mut self, input: impl Into<crate::model::AdminAccount>) -> Self {
            let mut v = self.admin_accounts.unwrap_or_default();
            v.push(input.into());
            self.admin_accounts = Some(v);
            self
        }
        /// <p>The list of Security Hub administrator accounts.</p>
        pub fn set_admin_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AdminAccount>>,
        ) -> Self {
            self.admin_accounts = input;
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListOrganizationAdminAccountsOutput`](crate::output::ListOrganizationAdminAccountsOutput)
        pub fn build(self) -> crate::output::ListOrganizationAdminAccountsOutput {
            crate::output::ListOrganizationAdminAccountsOutput {
                admin_accounts: self.admin_accounts,
                next_token: self.next_token,
            }
        }
    }
}
impl ListOrganizationAdminAccountsOutput {
    /// Creates a new builder-style object to manufacture [`ListOrganizationAdminAccountsOutput`](crate::output::ListOrganizationAdminAccountsOutput)
    pub fn builder() -> crate::output::list_organization_admin_accounts_output::Builder {
        crate::output::list_organization_admin_accounts_output::Builder::default()
    }
}

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListEnabledProductsForImportOutput {
    /// <p>The list of ARNs for the resources that represent your subscriptions to products. </p>
    pub product_subscriptions: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>The pagination token to use to request the next page of results.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for ListEnabledProductsForImportOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListEnabledProductsForImportOutput");
        formatter.field("product_subscriptions", &self.product_subscriptions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListEnabledProductsForImportOutput`](crate::output::ListEnabledProductsForImportOutput)
pub mod list_enabled_products_for_import_output {
    /// A builder for [`ListEnabledProductsForImportOutput`](crate::output::ListEnabledProductsForImportOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) product_subscriptions: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `product_subscriptions`.
        ///
        /// To override the contents of this collection use [`set_product_subscriptions`](Self::set_product_subscriptions).
        ///
        /// <p>The list of ARNs for the resources that represent your subscriptions to products. </p>
        pub fn product_subscriptions(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.product_subscriptions.unwrap_or_default();
            v.push(input.into());
            self.product_subscriptions = Some(v);
            self
        }
        /// <p>The list of ARNs for the resources that represent your subscriptions to products. </p>
        pub fn set_product_subscriptions(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.product_subscriptions = input;
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEnabledProductsForImportOutput`](crate::output::ListEnabledProductsForImportOutput)
        pub fn build(self) -> crate::output::ListEnabledProductsForImportOutput {
            crate::output::ListEnabledProductsForImportOutput {
                product_subscriptions: self.product_subscriptions,
                next_token: self.next_token,
            }
        }
    }
}
impl ListEnabledProductsForImportOutput {
    /// Creates a new builder-style object to manufacture [`ListEnabledProductsForImportOutput`](crate::output::ListEnabledProductsForImportOutput)
    pub fn builder() -> crate::output::list_enabled_products_for_import_output::Builder {
        crate::output::list_enabled_products_for_import_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct InviteMembersOutput {
    /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
    /// includes the account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for InviteMembersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("InviteMembersOutput");
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`InviteMembersOutput`](crate::output::InviteMembersOutput)
pub mod invite_members_output {
    /// A builder for [`InviteMembersOutput`](crate::output::InviteMembersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
        /// includes the account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
        /// includes the account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`InviteMembersOutput`](crate::output::InviteMembersOutput)
        pub fn build(self) -> crate::output::InviteMembersOutput {
            crate::output::InviteMembersOutput {
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl InviteMembersOutput {
    /// Creates a new builder-style object to manufacture [`InviteMembersOutput`](crate::output::InviteMembersOutput)
    pub fn builder() -> crate::output::invite_members_output::Builder {
        crate::output::invite_members_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetMembersOutput {
    /// <p>The list of details about the Security Hub member accounts.</p>
    pub members: std::option::Option<std::vec::Vec<crate::model::Member>>,
    /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
    /// includes the account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for GetMembersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetMembersOutput");
        formatter.field("members", &self.members);
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`GetMembersOutput`](crate::output::GetMembersOutput)
pub mod get_members_output {
    /// A builder for [`GetMembersOutput`](crate::output::GetMembersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) members: std::option::Option<std::vec::Vec<crate::model::Member>>,
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `members`.
        ///
        /// To override the contents of this collection use [`set_members`](Self::set_members).
        ///
        /// <p>The list of details about the Security Hub member accounts.</p>
        pub fn members(mut self, input: impl Into<crate::model::Member>) -> Self {
            let mut v = self.members.unwrap_or_default();
            v.push(input.into());
            self.members = Some(v);
            self
        }
        /// <p>The list of details about the Security Hub member accounts.</p>
        pub fn set_members(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Member>>,
        ) -> Self {
            self.members = input;
            self
        }
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
        /// includes the account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts that could not be processed. For each account, the list
        /// includes the account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`GetMembersOutput`](crate::output::GetMembersOutput)
        pub fn build(self) -> crate::output::GetMembersOutput {
            crate::output::GetMembersOutput {
                members: self.members,
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl GetMembersOutput {
    /// Creates a new builder-style object to manufacture [`GetMembersOutput`](crate::output::GetMembersOutput)
    pub fn builder() -> crate::output::get_members_output::Builder {
        crate::output::get_members_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetMasterAccountOutput {
    /// <p>A list of details about the Security Hub administrator account for the current member account.
    /// </p>
    pub master: std::option::Option<crate::model::Invitation>,
}
impl std::fmt::Debug for GetMasterAccountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetMasterAccountOutput");
        formatter.field("master", &self.master);
        formatter.finish()
    }
}
/// See [`GetMasterAccountOutput`](crate::output::GetMasterAccountOutput)
pub mod get_master_account_output {
    /// A builder for [`GetMasterAccountOutput`](crate::output::GetMasterAccountOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) master: std::option::Option<crate::model::Invitation>,
    }
    impl Builder {
        /// <p>A list of details about the Security Hub administrator account for the current member account.
        /// </p>
        pub fn master(mut self, input: crate::model::Invitation) -> Self {
            self.master = Some(input);
            self
        }
        /// <p>A list of details about the Security Hub administrator account for the current member account.
        /// </p>
        pub fn set_master(mut self, input: std::option::Option<crate::model::Invitation>) -> Self {
            self.master = input;
            self
        }
        /// Consumes the builder and constructs a [`GetMasterAccountOutput`](crate::output::GetMasterAccountOutput)
        pub fn build(self) -> crate::output::GetMasterAccountOutput {
            crate::output::GetMasterAccountOutput {
                master: self.master,
            }
        }
    }
}
impl GetMasterAccountOutput {
    /// Creates a new builder-style object to manufacture [`GetMasterAccountOutput`](crate::output::GetMasterAccountOutput)
    pub fn builder() -> crate::output::get_master_account_output::Builder {
        crate::output::get_master_account_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetInvitationsCountOutput {
    /// <p>The number of all membership invitations sent to this Security Hub member account, not
    /// including the currently accepted invitation.</p>
    pub invitations_count: i32,
}
impl std::fmt::Debug for GetInvitationsCountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetInvitationsCountOutput");
        formatter.field("invitations_count", &self.invitations_count);
        formatter.finish()
    }
}
/// See [`GetInvitationsCountOutput`](crate::output::GetInvitationsCountOutput)
pub mod get_invitations_count_output {
    /// A builder for [`GetInvitationsCountOutput`](crate::output::GetInvitationsCountOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) invitations_count: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>The number of all membership invitations sent to this Security Hub member account, not
        /// including the currently accepted invitation.</p>
        pub fn invitations_count(mut self, input: i32) -> Self {
            self.invitations_count = Some(input);
            self
        }
        /// <p>The number of all membership invitations sent to this Security Hub member account, not
        /// including the currently accepted invitation.</p>
        pub fn set_invitations_count(mut self, input: std::option::Option<i32>) -> Self {
            self.invitations_count = input;
            self
        }
        /// Consumes the builder and constructs a [`GetInvitationsCountOutput`](crate::output::GetInvitationsCountOutput)
        pub fn build(self) -> crate::output::GetInvitationsCountOutput {
            crate::output::GetInvitationsCountOutput {
                invitations_count: self.invitations_count.unwrap_or_default(),
            }
        }
    }
}
impl GetInvitationsCountOutput {
    /// Creates a new builder-style object to manufacture [`GetInvitationsCountOutput`](crate::output::GetInvitationsCountOutput)
    pub fn builder() -> crate::output::get_invitations_count_output::Builder {
        crate::output::get_invitations_count_output::Builder::default()
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeProductsOutput {
    /// <p>A list of products, including details for each product.</p>
    pub products: std::option::Option<std::vec::Vec<crate::model::Product>>,
    /// <p>The pagination token to use to request the next page of results.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeProductsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeProductsOutput");
        formatter.field("products", &self.products);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeProductsOutput`](crate::output::DescribeProductsOutput)
pub mod describe_products_output {
    /// A builder for [`DescribeProductsOutput`](crate::output::DescribeProductsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) products: std::option::Option<std::vec::Vec<crate::model::Product>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `products`.
        ///
        /// To override the contents of this collection use [`set_products`](Self::set_products).
        ///
        /// <p>A list of products, including details for each product.</p>
        pub fn products(mut self, input: impl Into<crate::model::Product>) -> Self {
            let mut v = self.products.unwrap_or_default();
            v.push(input.into());
            self.products = Some(v);
            self
        }
        /// <p>A list of products, including details for each product.</p>
        pub fn set_products(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Product>>,
        ) -> Self {
            self.products = input;
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeProductsOutput`](crate::output::DescribeProductsOutput)
        pub fn build(self) -> crate::output::DescribeProductsOutput {
            crate::output::DescribeProductsOutput {
                products: self.products,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeProductsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeProductsOutput`](crate::output::DescribeProductsOutput)
    pub fn builder() -> crate::output::describe_products_output::Builder {
        crate::output::describe_products_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeOrganizationConfigurationOutput {
    /// <p>Whether to automatically enable Security Hub for new accounts in the organization.</p>
    /// <p>If set to <code>true</code>, then Security Hub is enabled for new accounts. If set to false,
    /// then new accounts are not added automatically.</p>
    pub auto_enable: bool,
    /// <p>Whether the maximum number of allowed member accounts are already associated with the
    /// Security Hub administrator account.</p>
    pub member_account_limit_reached: bool,
}
impl std::fmt::Debug for DescribeOrganizationConfigurationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeOrganizationConfigurationOutput");
        formatter.field("auto_enable", &self.auto_enable);
        formatter.field(
            "member_account_limit_reached",
            &self.member_account_limit_reached,
        );
        formatter.finish()
    }
}
/// See [`DescribeOrganizationConfigurationOutput`](crate::output::DescribeOrganizationConfigurationOutput)
pub mod describe_organization_configuration_output {
    /// A builder for [`DescribeOrganizationConfigurationOutput`](crate::output::DescribeOrganizationConfigurationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) auto_enable: std::option::Option<bool>,
        pub(crate) member_account_limit_reached: std::option::Option<bool>,
    }
    impl Builder {
        /// <p>Whether to automatically enable Security Hub for new accounts in the organization.</p>
        /// <p>If set to <code>true</code>, then Security Hub is enabled for new accounts. If set to false,
        /// then new accounts are not added automatically.</p>
        pub fn auto_enable(mut self, input: bool) -> Self {
            self.auto_enable = Some(input);
            self
        }
        /// <p>Whether to automatically enable Security Hub for new accounts in the organization.</p>
        /// <p>If set to <code>true</code>, then Security Hub is enabled for new accounts. If set to false,
        /// then new accounts are not added automatically.</p>
        pub fn set_auto_enable(mut self, input: std::option::Option<bool>) -> Self {
            self.auto_enable = input;
            self
        }
        /// <p>Whether the maximum number of allowed member accounts are already associated with the
        /// Security Hub administrator account.</p>
        pub fn member_account_limit_reached(mut self, input: bool) -> Self {
            self.member_account_limit_reached = Some(input);
            self
        }
        /// <p>Whether the maximum number of allowed member accounts are already associated with the
        /// Security Hub administrator account.</p>
        pub fn set_member_account_limit_reached(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.member_account_limit_reached = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeOrganizationConfigurationOutput`](crate::output::DescribeOrganizationConfigurationOutput)
        pub fn build(self) -> crate::output::DescribeOrganizationConfigurationOutput {
            crate::output::DescribeOrganizationConfigurationOutput {
                auto_enable: self.auto_enable.unwrap_or_default(),
                member_account_limit_reached: self.member_account_limit_reached.unwrap_or_default(),
            }
        }
    }
}
impl DescribeOrganizationConfigurationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeOrganizationConfigurationOutput`](crate::output::DescribeOrganizationConfigurationOutput)
    pub fn builder() -> crate::output::describe_organization_configuration_output::Builder {
        crate::output::describe_organization_configuration_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeHubOutput {
    /// <p>The ARN of the Hub resource that was retrieved.</p>
    pub hub_arn: std::option::Option<std::string::String>,
    /// <p>The date and time when Security Hub was enabled in the account.</p>
    pub subscribed_at: std::option::Option<std::string::String>,
    /// <p>Whether to automatically enable new controls when they are added to standards that are
    /// enabled.</p>
    /// <p>If set to <code>true</code>, then new controls for enabled standards are enabled
    /// automatically. If set to <code>false</code>, then new controls are not enabled.</p>
    pub auto_enable_controls: bool,
}
impl std::fmt::Debug for DescribeHubOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeHubOutput");
        formatter.field("hub_arn", &self.hub_arn);
        formatter.field("subscribed_at", &self.subscribed_at);
        formatter.field("auto_enable_controls", &self.auto_enable_controls);
        formatter.finish()
    }
}
/// See [`DescribeHubOutput`](crate::output::DescribeHubOutput)
pub mod describe_hub_output {
    /// A builder for [`DescribeHubOutput`](crate::output::DescribeHubOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) hub_arn: std::option::Option<std::string::String>,
        pub(crate) subscribed_at: std::option::Option<std::string::String>,
        pub(crate) auto_enable_controls: std::option::Option<bool>,
    }
    impl Builder {
        /// <p>The ARN of the Hub resource that was retrieved.</p>
        pub fn hub_arn(mut self, input: impl Into<std::string::String>) -> Self {
            self.hub_arn = Some(input.into());
            self
        }
        /// <p>The ARN of the Hub resource that was retrieved.</p>
        pub fn set_hub_arn(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.hub_arn = input;
            self
        }
        /// <p>The date and time when Security Hub was enabled in the account.</p>
        pub fn subscribed_at(mut self, input: impl Into<std::string::String>) -> Self {
            self.subscribed_at = Some(input.into());
            self
        }
        /// <p>The date and time when Security Hub was enabled in the account.</p>
        pub fn set_subscribed_at(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.subscribed_at = input;
            self
        }
        /// <p>Whether to automatically enable new controls when they are added to standards that are
        /// enabled.</p>
        /// <p>If set to <code>true</code>, then new controls for enabled standards are enabled
        /// automatically. If set to <code>false</code>, then new controls are not enabled.</p>
        pub fn auto_enable_controls(mut self, input: bool) -> Self {
            self.auto_enable_controls = Some(input);
            self
        }
        /// <p>Whether to automatically enable new controls when they are added to standards that are
        /// enabled.</p>
        /// <p>If set to <code>true</code>, then new controls for enabled standards are enabled
        /// automatically. If set to <code>false</code>, then new controls are not enabled.</p>
        pub fn set_auto_enable_controls(mut self, input: std::option::Option<bool>) -> Self {
            self.auto_enable_controls = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeHubOutput`](crate::output::DescribeHubOutput)
        pub fn build(self) -> crate::output::DescribeHubOutput {
            crate::output::DescribeHubOutput {
                hub_arn: self.hub_arn,
                subscribed_at: self.subscribed_at,
                auto_enable_controls: self.auto_enable_controls.unwrap_or_default(),
            }
        }
    }
}
impl DescribeHubOutput {
    /// Creates a new builder-style object to manufacture [`DescribeHubOutput`](crate::output::DescribeHubOutput)
    pub fn builder() -> crate::output::describe_hub_output::Builder {
        crate::output::describe_hub_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeActionTargetsOutput {
    /// <p>A list of <code>ActionTarget</code> objects. Each object includes the <code>ActionTargetArn</code>,
    /// <code>Description</code>, and <code>Name</code> of a custom action target available in
    /// Security Hub.</p>
    pub action_targets: std::option::Option<std::vec::Vec<crate::model::ActionTarget>>,
    /// <p>The pagination token to use to request the next page of results.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeActionTargetsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeActionTargetsOutput");
        formatter.field("action_targets", &self.action_targets);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeActionTargetsOutput`](crate::output::DescribeActionTargetsOutput)
pub mod describe_action_targets_output {
    /// A builder for [`DescribeActionTargetsOutput`](crate::output::DescribeActionTargetsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) action_targets: std::option::Option<std::vec::Vec<crate::model::ActionTarget>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `action_targets`.
        ///
        /// To override the contents of this collection use [`set_action_targets`](Self::set_action_targets).
        ///
        /// <p>A list of <code>ActionTarget</code> objects. Each object includes the <code>ActionTargetArn</code>,
        /// <code>Description</code>, and <code>Name</code> of a custom action target available in
        /// Security Hub.</p>
        pub fn action_targets(mut self, input: impl Into<crate::model::ActionTarget>) -> Self {
            let mut v = self.action_targets.unwrap_or_default();
            v.push(input.into());
            self.action_targets = Some(v);
            self
        }
        /// <p>A list of <code>ActionTarget</code> objects. Each object includes the <code>ActionTargetArn</code>,
        /// <code>Description</code>, and <code>Name</code> of a custom action target available in
        /// Security Hub.</p>
        pub fn set_action_targets(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ActionTarget>>,
        ) -> Self {
            self.action_targets = input;
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>The pagination token to use to request the next page of results.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeActionTargetsOutput`](crate::output::DescribeActionTargetsOutput)
        pub fn build(self) -> crate::output::DescribeActionTargetsOutput {
            crate::output::DescribeActionTargetsOutput {
                action_targets: self.action_targets,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeActionTargetsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeActionTargetsOutput`](crate::output::DescribeActionTargetsOutput)
    pub fn builder() -> crate::output::describe_action_targets_output::Builder {
        crate::output::describe_action_targets_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteMembersOutput {
    /// <p>The list of Amazon Web Services accounts that were not deleted. For each account, the list includes the
    /// account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for DeleteMembersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteMembersOutput");
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`DeleteMembersOutput`](crate::output::DeleteMembersOutput)
pub mod delete_members_output {
    /// A builder for [`DeleteMembersOutput`](crate::output::DeleteMembersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts that were not deleted. For each account, the list includes the
        /// account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts that were not deleted. For each account, the list includes the
        /// account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteMembersOutput`](crate::output::DeleteMembersOutput)
        pub fn build(self) -> crate::output::DeleteMembersOutput {
            crate::output::DeleteMembersOutput {
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl DeleteMembersOutput {
    /// Creates a new builder-style object to manufacture [`DeleteMembersOutput`](crate::output::DeleteMembersOutput)
    pub fn builder() -> crate::output::delete_members_output::Builder {
        crate::output::delete_members_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteInvitationsOutput {
    /// <p>The list of Amazon Web Services accounts for which the invitations were not deleted. For each account,
    /// the list includes the account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for DeleteInvitationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteInvitationsOutput");
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`DeleteInvitationsOutput`](crate::output::DeleteInvitationsOutput)
pub mod delete_invitations_output {
    /// A builder for [`DeleteInvitationsOutput`](crate::output::DeleteInvitationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts for which the invitations were not deleted. For each account,
        /// the list includes the account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts for which the invitations were not deleted. For each account,
        /// the list includes the account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteInvitationsOutput`](crate::output::DeleteInvitationsOutput)
        pub fn build(self) -> crate::output::DeleteInvitationsOutput {
            crate::output::DeleteInvitationsOutput {
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl DeleteInvitationsOutput {
    /// Creates a new builder-style object to manufacture [`DeleteInvitationsOutput`](crate::output::DeleteInvitationsOutput)
    pub fn builder() -> crate::output::delete_invitations_output::Builder {
        crate::output::delete_invitations_output::Builder::default()
    }
}

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeclineInvitationsOutput {
    /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
    /// the account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for DeclineInvitationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeclineInvitationsOutput");
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`DeclineInvitationsOutput`](crate::output::DeclineInvitationsOutput)
pub mod decline_invitations_output {
    /// A builder for [`DeclineInvitationsOutput`](crate::output::DeclineInvitationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
        /// the account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
        /// the account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`DeclineInvitationsOutput`](crate::output::DeclineInvitationsOutput)
        pub fn build(self) -> crate::output::DeclineInvitationsOutput {
            crate::output::DeclineInvitationsOutput {
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl DeclineInvitationsOutput {
    /// Creates a new builder-style object to manufacture [`DeclineInvitationsOutput`](crate::output::DeclineInvitationsOutput)
    pub fn builder() -> crate::output::decline_invitations_output::Builder {
        crate::output::decline_invitations_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateMembersOutput {
    /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
    /// the account ID and the email address.</p>
    pub unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
}
impl std::fmt::Debug for CreateMembersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateMembersOutput");
        formatter.field("unprocessed_accounts", &self.unprocessed_accounts);
        formatter.finish()
    }
}
/// See [`CreateMembersOutput`](crate::output::CreateMembersOutput)
pub mod create_members_output {
    /// A builder for [`CreateMembersOutput`](crate::output::CreateMembersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) unprocessed_accounts: std::option::Option<std::vec::Vec<crate::model::Result>>,
    }
    impl Builder {
        /// Appends an item to `unprocessed_accounts`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_accounts`](Self::set_unprocessed_accounts).
        ///
        /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
        /// the account ID and the email address.</p>
        pub fn unprocessed_accounts(mut self, input: impl Into<crate::model::Result>) -> Self {
            let mut v = self.unprocessed_accounts.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_accounts = Some(v);
            self
        }
        /// <p>The list of Amazon Web Services accounts that were not processed. For each account, the list includes
        /// the account ID and the email address.</p>
        pub fn set_unprocessed_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Result>>,
        ) -> Self {
            self.unprocessed_accounts = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateMembersOutput`](crate::output::CreateMembersOutput)
        pub fn build(self) -> crate::output::CreateMembersOutput {
            crate::output::CreateMembersOutput {
                unprocessed_accounts: self.unprocessed_accounts,
            }
        }
    }
}
impl CreateMembersOutput {
    /// Creates a new builder-style object to manufacture [`CreateMembersOutput`](crate::output::CreateMembersOutput)
    pub fn builder() -> crate::output::create_members_output::Builder {
        crate::output::create_members_output::Builder::default()
    }
}

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

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

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BatchUpdateFindingsOutput {
    /// <p>The list of findings that were updated successfully.</p>
    pub processed_findings:
        std::option::Option<std::vec::Vec<crate::model::AwsSecurityFindingIdentifier>>,
    /// <p>The list of findings that were not updated.</p>
    pub unprocessed_findings:
        std::option::Option<std::vec::Vec<crate::model::BatchUpdateFindingsUnprocessedFinding>>,
}
impl std::fmt::Debug for BatchUpdateFindingsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BatchUpdateFindingsOutput");
        formatter.field("processed_findings", &self.processed_findings);
        formatter.field("unprocessed_findings", &self.unprocessed_findings);
        formatter.finish()
    }
}
/// See [`BatchUpdateFindingsOutput`](crate::output::BatchUpdateFindingsOutput)
pub mod batch_update_findings_output {
    /// A builder for [`BatchUpdateFindingsOutput`](crate::output::BatchUpdateFindingsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) processed_findings:
            std::option::Option<std::vec::Vec<crate::model::AwsSecurityFindingIdentifier>>,
        pub(crate) unprocessed_findings:
            std::option::Option<std::vec::Vec<crate::model::BatchUpdateFindingsUnprocessedFinding>>,
    }
    impl Builder {
        /// Appends an item to `processed_findings`.
        ///
        /// To override the contents of this collection use [`set_processed_findings`](Self::set_processed_findings).
        ///
        /// <p>The list of findings that were updated successfully.</p>
        pub fn processed_findings(
            mut self,
            input: impl Into<crate::model::AwsSecurityFindingIdentifier>,
        ) -> Self {
            let mut v = self.processed_findings.unwrap_or_default();
            v.push(input.into());
            self.processed_findings = Some(v);
            self
        }
        /// <p>The list of findings that were updated successfully.</p>
        pub fn set_processed_findings(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AwsSecurityFindingIdentifier>>,
        ) -> Self {
            self.processed_findings = input;
            self
        }
        /// Appends an item to `unprocessed_findings`.
        ///
        /// To override the contents of this collection use [`set_unprocessed_findings`](Self::set_unprocessed_findings).
        ///
        /// <p>The list of findings that were not updated.</p>
        pub fn unprocessed_findings(
            mut self,
            input: impl Into<crate::model::BatchUpdateFindingsUnprocessedFinding>,
        ) -> Self {
            let mut v = self.unprocessed_findings.unwrap_or_default();
            v.push(input.into());
            self.unprocessed_findings = Some(v);
            self
        }
        /// <p>The list of findings that were not updated.</p>
        pub fn set_unprocessed_findings(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::BatchUpdateFindingsUnprocessedFinding>,
            >,
        ) -> Self {
            self.unprocessed_findings = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchUpdateFindingsOutput`](crate::output::BatchUpdateFindingsOutput)
        pub fn build(self) -> crate::output::BatchUpdateFindingsOutput {
            crate::output::BatchUpdateFindingsOutput {
                processed_findings: self.processed_findings,
                unprocessed_findings: self.unprocessed_findings,
            }
        }
    }
}
impl BatchUpdateFindingsOutput {
    /// Creates a new builder-style object to manufacture [`BatchUpdateFindingsOutput`](crate::output::BatchUpdateFindingsOutput)
    pub fn builder() -> crate::output::batch_update_findings_output::Builder {
        crate::output::batch_update_findings_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct BatchImportFindingsOutput {
    /// <p>The number of findings that failed to import.</p>
    pub failed_count: i32,
    /// <p>The number of findings that were successfully imported.</p>
    pub success_count: i32,
    /// <p>The list of findings that failed to import.</p>
    pub failed_findings: std::option::Option<std::vec::Vec<crate::model::ImportFindingsError>>,
}
impl std::fmt::Debug for BatchImportFindingsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("BatchImportFindingsOutput");
        formatter.field("failed_count", &self.failed_count);
        formatter.field("success_count", &self.success_count);
        formatter.field("failed_findings", &self.failed_findings);
        formatter.finish()
    }
}
/// See [`BatchImportFindingsOutput`](crate::output::BatchImportFindingsOutput)
pub mod batch_import_findings_output {
    /// A builder for [`BatchImportFindingsOutput`](crate::output::BatchImportFindingsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) failed_count: std::option::Option<i32>,
        pub(crate) success_count: std::option::Option<i32>,
        pub(crate) failed_findings:
            std::option::Option<std::vec::Vec<crate::model::ImportFindingsError>>,
    }
    impl Builder {
        /// <p>The number of findings that failed to import.</p>
        pub fn failed_count(mut self, input: i32) -> Self {
            self.failed_count = Some(input);
            self
        }
        /// <p>The number of findings that failed to import.</p>
        pub fn set_failed_count(mut self, input: std::option::Option<i32>) -> Self {
            self.failed_count = input;
            self
        }
        /// <p>The number of findings that were successfully imported.</p>
        pub fn success_count(mut self, input: i32) -> Self {
            self.success_count = Some(input);
            self
        }
        /// <p>The number of findings that were successfully imported.</p>
        pub fn set_success_count(mut self, input: std::option::Option<i32>) -> Self {
            self.success_count = input;
            self
        }
        /// Appends an item to `failed_findings`.
        ///
        /// To override the contents of this collection use [`set_failed_findings`](Self::set_failed_findings).
        ///
        /// <p>The list of findings that failed to import.</p>
        pub fn failed_findings(
            mut self,
            input: impl Into<crate::model::ImportFindingsError>,
        ) -> Self {
            let mut v = self.failed_findings.unwrap_or_default();
            v.push(input.into());
            self.failed_findings = Some(v);
            self
        }
        /// <p>The list of findings that failed to import.</p>
        pub fn set_failed_findings(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ImportFindingsError>>,
        ) -> Self {
            self.failed_findings = input;
            self
        }
        /// Consumes the builder and constructs a [`BatchImportFindingsOutput`](crate::output::BatchImportFindingsOutput)
        pub fn build(self) -> crate::output::BatchImportFindingsOutput {
            crate::output::BatchImportFindingsOutput {
                failed_count: self.failed_count.unwrap_or_default(),
                success_count: self.success_count.unwrap_or_default(),
                failed_findings: self.failed_findings,
            }
        }
    }
}
impl BatchImportFindingsOutput {
    /// Creates a new builder-style object to manufacture [`BatchImportFindingsOutput`](crate::output::BatchImportFindingsOutput)
    pub fn builder() -> crate::output::batch_import_findings_output::Builder {
        crate::output::batch_import_findings_output::Builder::default()
    }
}

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

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

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

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