output.rs

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct EnableHealthServiceAccessForOrganizationOutput {}
impl std::fmt::Debug for EnableHealthServiceAccessForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("EnableHealthServiceAccessForOrganizationOutput");
        formatter.finish()
    }
}
/// See [`EnableHealthServiceAccessForOrganizationOutput`](crate::output::EnableHealthServiceAccessForOrganizationOutput)
pub mod enable_health_service_access_for_organization_output {
    /// A builder for [`EnableHealthServiceAccessForOrganizationOutput`](crate::output::EnableHealthServiceAccessForOrganizationOutput)
    #[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 [`EnableHealthServiceAccessForOrganizationOutput`](crate::output::EnableHealthServiceAccessForOrganizationOutput)
        pub fn build(self) -> crate::output::EnableHealthServiceAccessForOrganizationOutput {
            crate::output::EnableHealthServiceAccessForOrganizationOutput {}
        }
    }
}
impl EnableHealthServiceAccessForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`EnableHealthServiceAccessForOrganizationOutput`](crate::output::EnableHealthServiceAccessForOrganizationOutput)
    pub fn builder() -> crate::output::enable_health_service_access_for_organization_output::Builder
    {
        crate::output::enable_health_service_access_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DisableHealthServiceAccessForOrganizationOutput {}
impl std::fmt::Debug for DisableHealthServiceAccessForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DisableHealthServiceAccessForOrganizationOutput");
        formatter.finish()
    }
}
/// See [`DisableHealthServiceAccessForOrganizationOutput`](crate::output::DisableHealthServiceAccessForOrganizationOutput)
pub mod disable_health_service_access_for_organization_output {
    /// A builder for [`DisableHealthServiceAccessForOrganizationOutput`](crate::output::DisableHealthServiceAccessForOrganizationOutput)
    #[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 [`DisableHealthServiceAccessForOrganizationOutput`](crate::output::DisableHealthServiceAccessForOrganizationOutput)
        pub fn build(self) -> crate::output::DisableHealthServiceAccessForOrganizationOutput {
            crate::output::DisableHealthServiceAccessForOrganizationOutput {}
        }
    }
}
impl DisableHealthServiceAccessForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DisableHealthServiceAccessForOrganizationOutput`](crate::output::DisableHealthServiceAccessForOrganizationOutput)
    pub fn builder() -> crate::output::disable_health_service_access_for_organization_output::Builder
    {
        crate::output::disable_health_service_access_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeHealthServiceStatusForOrganizationOutput {
    /// <p>Information about the status of enabling or disabling AWS Health Organizational View in
    /// your organization.</p>
    /// <p>Valid values are <code>ENABLED | DISABLED | PENDING</code>. </p>
    pub health_service_access_status_for_organization: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeHealthServiceStatusForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeHealthServiceStatusForOrganizationOutput");
        formatter.field(
            "health_service_access_status_for_organization",
            &self.health_service_access_status_for_organization,
        );
        formatter.finish()
    }
}
/// See [`DescribeHealthServiceStatusForOrganizationOutput`](crate::output::DescribeHealthServiceStatusForOrganizationOutput)
pub mod describe_health_service_status_for_organization_output {
    /// A builder for [`DescribeHealthServiceStatusForOrganizationOutput`](crate::output::DescribeHealthServiceStatusForOrganizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) health_service_access_status_for_organization:
            std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>Information about the status of enabling or disabling AWS Health Organizational View in
        /// your organization.</p>
        /// <p>Valid values are <code>ENABLED | DISABLED | PENDING</code>. </p>
        pub fn health_service_access_status_for_organization(
            mut self,
            input: impl Into<std::string::String>,
        ) -> Self {
            self.health_service_access_status_for_organization = Some(input.into());
            self
        }
        pub fn set_health_service_access_status_for_organization(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.health_service_access_status_for_organization = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeHealthServiceStatusForOrganizationOutput`](crate::output::DescribeHealthServiceStatusForOrganizationOutput)
        pub fn build(self) -> crate::output::DescribeHealthServiceStatusForOrganizationOutput {
            crate::output::DescribeHealthServiceStatusForOrganizationOutput {
                health_service_access_status_for_organization: self
                    .health_service_access_status_for_organization,
            }
        }
    }
}
impl DescribeHealthServiceStatusForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeHealthServiceStatusForOrganizationOutput`](crate::output::DescribeHealthServiceStatusForOrganizationOutput)
    pub fn builder(
    ) -> crate::output::describe_health_service_status_for_organization_output::Builder {
        crate::output::describe_health_service_status_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventTypesOutput {
    /// <p>A list of event types that match the filter criteria. Event types have a category
    /// (<code>issue</code>, <code>accountNotification</code>, or <code>scheduledChange</code>),
    /// a service (for example, <code>EC2</code>, <code>RDS</code>, <code>DATAPIPELINE</code>,
    /// <code>BILLING</code>), and a code (in the format
    /// <code>AWS_<i>SERVICE</i>_<i>DESCRIPTION</i>
    /// </code>; for
    /// example, <code>AWS_EC2_SYSTEM_MAINTENANCE_EVENT</code>).</p>
    pub event_types: std::option::Option<std::vec::Vec<crate::model::EventType>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeEventTypesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventTypesOutput");
        formatter.field("event_types", &self.event_types);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeEventTypesOutput`](crate::output::DescribeEventTypesOutput)
pub mod describe_event_types_output {
    /// A builder for [`DescribeEventTypesOutput`](crate::output::DescribeEventTypesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) event_types: std::option::Option<std::vec::Vec<crate::model::EventType>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn event_types(mut self, input: impl Into<crate::model::EventType>) -> Self {
            let mut v = self.event_types.unwrap_or_default();
            v.push(input.into());
            self.event_types = Some(v);
            self
        }
        pub fn set_event_types(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EventType>>,
        ) -> Self {
            self.event_types = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventTypesOutput`](crate::output::DescribeEventTypesOutput)
        pub fn build(self) -> crate::output::DescribeEventTypesOutput {
            crate::output::DescribeEventTypesOutput {
                event_types: self.event_types,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeEventTypesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventTypesOutput`](crate::output::DescribeEventTypesOutput)
    pub fn builder() -> crate::output::describe_event_types_output::Builder {
        crate::output::describe_event_types_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventsForOrganizationOutput {
    /// <p>The events that match the specified filter criteria.</p>
    pub events: std::option::Option<std::vec::Vec<crate::model::OrganizationEvent>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeEventsForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventsForOrganizationOutput");
        formatter.field("events", &self.events);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeEventsForOrganizationOutput`](crate::output::DescribeEventsForOrganizationOutput)
pub mod describe_events_for_organization_output {
    /// A builder for [`DescribeEventsForOrganizationOutput`](crate::output::DescribeEventsForOrganizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) events: std::option::Option<std::vec::Vec<crate::model::OrganizationEvent>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn events(mut self, input: impl Into<crate::model::OrganizationEvent>) -> Self {
            let mut v = self.events.unwrap_or_default();
            v.push(input.into());
            self.events = Some(v);
            self
        }
        pub fn set_events(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OrganizationEvent>>,
        ) -> Self {
            self.events = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventsForOrganizationOutput`](crate::output::DescribeEventsForOrganizationOutput)
        pub fn build(self) -> crate::output::DescribeEventsForOrganizationOutput {
            crate::output::DescribeEventsForOrganizationOutput {
                events: self.events,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeEventsForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventsForOrganizationOutput`](crate::output::DescribeEventsForOrganizationOutput)
    pub fn builder() -> crate::output::describe_events_for_organization_output::Builder {
        crate::output::describe_events_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventsOutput {
    /// <p>The events that match the specified filter criteria.</p>
    pub events: std::option::Option<std::vec::Vec<crate::model::Event>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventsOutput");
        formatter.field("events", &self.events);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
pub mod describe_events_output {
    /// A builder for [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) events: std::option::Option<std::vec::Vec<crate::model::Event>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn events(mut self, input: impl Into<crate::model::Event>) -> Self {
            let mut v = self.events.unwrap_or_default();
            v.push(input.into());
            self.events = Some(v);
            self
        }
        pub fn set_events(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Event>>,
        ) -> Self {
            self.events = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
        pub fn build(self) -> crate::output::DescribeEventsOutput {
            crate::output::DescribeEventsOutput {
                events: self.events,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeEventsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventsOutput`](crate::output::DescribeEventsOutput)
    pub fn builder() -> crate::output::describe_events_output::Builder {
        crate::output::describe_events_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventDetailsForOrganizationOutput {
    /// <p>Information about the events that could be retrieved.</p>
    pub successful_set: std::option::Option<std::vec::Vec<crate::model::OrganizationEventDetails>>,
    /// <p>Error messages for any events that could not be retrieved.</p>
    pub failed_set:
        std::option::Option<std::vec::Vec<crate::model::OrganizationEventDetailsErrorItem>>,
}
impl std::fmt::Debug for DescribeEventDetailsForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventDetailsForOrganizationOutput");
        formatter.field("successful_set", &self.successful_set);
        formatter.field("failed_set", &self.failed_set);
        formatter.finish()
    }
}
/// See [`DescribeEventDetailsForOrganizationOutput`](crate::output::DescribeEventDetailsForOrganizationOutput)
pub mod describe_event_details_for_organization_output {
    /// A builder for [`DescribeEventDetailsForOrganizationOutput`](crate::output::DescribeEventDetailsForOrganizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) successful_set:
            std::option::Option<std::vec::Vec<crate::model::OrganizationEventDetails>>,
        pub(crate) failed_set:
            std::option::Option<std::vec::Vec<crate::model::OrganizationEventDetailsErrorItem>>,
    }
    impl Builder {
        pub fn successful_set(
            mut self,
            input: impl Into<crate::model::OrganizationEventDetails>,
        ) -> Self {
            let mut v = self.successful_set.unwrap_or_default();
            v.push(input.into());
            self.successful_set = Some(v);
            self
        }
        pub fn set_successful_set(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::OrganizationEventDetails>>,
        ) -> Self {
            self.successful_set = input;
            self
        }
        pub fn failed_set(
            mut self,
            input: impl Into<crate::model::OrganizationEventDetailsErrorItem>,
        ) -> Self {
            let mut v = self.failed_set.unwrap_or_default();
            v.push(input.into());
            self.failed_set = Some(v);
            self
        }
        pub fn set_failed_set(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::OrganizationEventDetailsErrorItem>,
            >,
        ) -> Self {
            self.failed_set = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventDetailsForOrganizationOutput`](crate::output::DescribeEventDetailsForOrganizationOutput)
        pub fn build(self) -> crate::output::DescribeEventDetailsForOrganizationOutput {
            crate::output::DescribeEventDetailsForOrganizationOutput {
                successful_set: self.successful_set,
                failed_set: self.failed_set,
            }
        }
    }
}
impl DescribeEventDetailsForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventDetailsForOrganizationOutput`](crate::output::DescribeEventDetailsForOrganizationOutput)
    pub fn builder() -> crate::output::describe_event_details_for_organization_output::Builder {
        crate::output::describe_event_details_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventDetailsOutput {
    /// <p>Information about the events that could be retrieved.</p>
    pub successful_set: std::option::Option<std::vec::Vec<crate::model::EventDetails>>,
    /// <p>Error messages for any events that could not be retrieved.</p>
    pub failed_set: std::option::Option<std::vec::Vec<crate::model::EventDetailsErrorItem>>,
}
impl std::fmt::Debug for DescribeEventDetailsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventDetailsOutput");
        formatter.field("successful_set", &self.successful_set);
        formatter.field("failed_set", &self.failed_set);
        formatter.finish()
    }
}
/// See [`DescribeEventDetailsOutput`](crate::output::DescribeEventDetailsOutput)
pub mod describe_event_details_output {
    /// A builder for [`DescribeEventDetailsOutput`](crate::output::DescribeEventDetailsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) successful_set: std::option::Option<std::vec::Vec<crate::model::EventDetails>>,
        pub(crate) failed_set:
            std::option::Option<std::vec::Vec<crate::model::EventDetailsErrorItem>>,
    }
    impl Builder {
        pub fn successful_set(mut self, input: impl Into<crate::model::EventDetails>) -> Self {
            let mut v = self.successful_set.unwrap_or_default();
            v.push(input.into());
            self.successful_set = Some(v);
            self
        }
        pub fn set_successful_set(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EventDetails>>,
        ) -> Self {
            self.successful_set = input;
            self
        }
        pub fn failed_set(mut self, input: impl Into<crate::model::EventDetailsErrorItem>) -> Self {
            let mut v = self.failed_set.unwrap_or_default();
            v.push(input.into());
            self.failed_set = Some(v);
            self
        }
        pub fn set_failed_set(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EventDetailsErrorItem>>,
        ) -> Self {
            self.failed_set = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventDetailsOutput`](crate::output::DescribeEventDetailsOutput)
        pub fn build(self) -> crate::output::DescribeEventDetailsOutput {
            crate::output::DescribeEventDetailsOutput {
                successful_set: self.successful_set,
                failed_set: self.failed_set,
            }
        }
    }
}
impl DescribeEventDetailsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventDetailsOutput`](crate::output::DescribeEventDetailsOutput)
    pub fn builder() -> crate::output::describe_event_details_output::Builder {
        crate::output::describe_event_details_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEventAggregatesOutput {
    /// <p>The number of events in each category that meet the optional filter criteria.</p>
    pub event_aggregates: std::option::Option<std::vec::Vec<crate::model::EventAggregate>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeEventAggregatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEventAggregatesOutput");
        formatter.field("event_aggregates", &self.event_aggregates);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeEventAggregatesOutput`](crate::output::DescribeEventAggregatesOutput)
pub mod describe_event_aggregates_output {
    /// A builder for [`DescribeEventAggregatesOutput`](crate::output::DescribeEventAggregatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) event_aggregates:
            std::option::Option<std::vec::Vec<crate::model::EventAggregate>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn event_aggregates(mut self, input: impl Into<crate::model::EventAggregate>) -> Self {
            let mut v = self.event_aggregates.unwrap_or_default();
            v.push(input.into());
            self.event_aggregates = Some(v);
            self
        }
        pub fn set_event_aggregates(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EventAggregate>>,
        ) -> Self {
            self.event_aggregates = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEventAggregatesOutput`](crate::output::DescribeEventAggregatesOutput)
        pub fn build(self) -> crate::output::DescribeEventAggregatesOutput {
            crate::output::DescribeEventAggregatesOutput {
                event_aggregates: self.event_aggregates,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeEventAggregatesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEventAggregatesOutput`](crate::output::DescribeEventAggregatesOutput)
    pub fn builder() -> crate::output::describe_event_aggregates_output::Builder {
        crate::output::describe_event_aggregates_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeEntityAggregatesOutput {
    /// <p>The number of entities that are affected by each of the specified events.</p>
    pub entity_aggregates: std::option::Option<std::vec::Vec<crate::model::EntityAggregate>>,
}
impl std::fmt::Debug for DescribeEntityAggregatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeEntityAggregatesOutput");
        formatter.field("entity_aggregates", &self.entity_aggregates);
        formatter.finish()
    }
}
/// See [`DescribeEntityAggregatesOutput`](crate::output::DescribeEntityAggregatesOutput)
pub mod describe_entity_aggregates_output {
    /// A builder for [`DescribeEntityAggregatesOutput`](crate::output::DescribeEntityAggregatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) entity_aggregates:
            std::option::Option<std::vec::Vec<crate::model::EntityAggregate>>,
    }
    impl Builder {
        pub fn entity_aggregates(
            mut self,
            input: impl Into<crate::model::EntityAggregate>,
        ) -> Self {
            let mut v = self.entity_aggregates.unwrap_or_default();
            v.push(input.into());
            self.entity_aggregates = Some(v);
            self
        }
        pub fn set_entity_aggregates(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EntityAggregate>>,
        ) -> Self {
            self.entity_aggregates = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeEntityAggregatesOutput`](crate::output::DescribeEntityAggregatesOutput)
        pub fn build(self) -> crate::output::DescribeEntityAggregatesOutput {
            crate::output::DescribeEntityAggregatesOutput {
                entity_aggregates: self.entity_aggregates,
            }
        }
    }
}
impl DescribeEntityAggregatesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeEntityAggregatesOutput`](crate::output::DescribeEntityAggregatesOutput)
    pub fn builder() -> crate::output::describe_entity_aggregates_output::Builder {
        crate::output::describe_entity_aggregates_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAffectedEntitiesForOrganizationOutput {
    /// <p>A JSON set of elements including the <code>awsAccountId</code> and its
    /// <code>entityArn</code>, <code>entityValue</code> and its <code>entityArn</code>,
    /// <code>lastUpdatedTime</code>, and <code>statusCode</code>.</p>
    pub entities: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
    /// <p>A JSON set of elements of the failed response, including the <code>awsAccountId</code>,
    /// <code>errorMessage</code>, <code>errorName</code>, and <code>eventArn</code>.</p>
    pub failed_set:
        std::option::Option<std::vec::Vec<crate::model::OrganizationAffectedEntitiesErrorItem>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeAffectedEntitiesForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAffectedEntitiesForOrganizationOutput");
        formatter.field("entities", &self.entities);
        formatter.field("failed_set", &self.failed_set);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAffectedEntitiesForOrganizationOutput`](crate::output::DescribeAffectedEntitiesForOrganizationOutput)
pub mod describe_affected_entities_for_organization_output {
    /// A builder for [`DescribeAffectedEntitiesForOrganizationOutput`](crate::output::DescribeAffectedEntitiesForOrganizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) entities: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
        pub(crate) failed_set:
            std::option::Option<std::vec::Vec<crate::model::OrganizationAffectedEntitiesErrorItem>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn entities(mut self, input: impl Into<crate::model::AffectedEntity>) -> Self {
            let mut v = self.entities.unwrap_or_default();
            v.push(input.into());
            self.entities = Some(v);
            self
        }
        pub fn set_entities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
        ) -> Self {
            self.entities = input;
            self
        }
        pub fn failed_set(
            mut self,
            input: impl Into<crate::model::OrganizationAffectedEntitiesErrorItem>,
        ) -> Self {
            let mut v = self.failed_set.unwrap_or_default();
            v.push(input.into());
            self.failed_set = Some(v);
            self
        }
        pub fn set_failed_set(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::OrganizationAffectedEntitiesErrorItem>,
            >,
        ) -> Self {
            self.failed_set = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAffectedEntitiesForOrganizationOutput`](crate::output::DescribeAffectedEntitiesForOrganizationOutput)
        pub fn build(self) -> crate::output::DescribeAffectedEntitiesForOrganizationOutput {
            crate::output::DescribeAffectedEntitiesForOrganizationOutput {
                entities: self.entities,
                failed_set: self.failed_set,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAffectedEntitiesForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAffectedEntitiesForOrganizationOutput`](crate::output::DescribeAffectedEntitiesForOrganizationOutput)
    pub fn builder() -> crate::output::describe_affected_entities_for_organization_output::Builder {
        crate::output::describe_affected_entities_for_organization_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAffectedEntitiesOutput {
    /// <p>The entities that match the filter criteria.</p>
    pub entities: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeAffectedEntitiesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAffectedEntitiesOutput");
        formatter.field("entities", &self.entities);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAffectedEntitiesOutput`](crate::output::DescribeAffectedEntitiesOutput)
pub mod describe_affected_entities_output {
    /// A builder for [`DescribeAffectedEntitiesOutput`](crate::output::DescribeAffectedEntitiesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) entities: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn entities(mut self, input: impl Into<crate::model::AffectedEntity>) -> Self {
            let mut v = self.entities.unwrap_or_default();
            v.push(input.into());
            self.entities = Some(v);
            self
        }
        pub fn set_entities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::AffectedEntity>>,
        ) -> Self {
            self.entities = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAffectedEntitiesOutput`](crate::output::DescribeAffectedEntitiesOutput)
        pub fn build(self) -> crate::output::DescribeAffectedEntitiesOutput {
            crate::output::DescribeAffectedEntitiesOutput {
                entities: self.entities,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAffectedEntitiesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAffectedEntitiesOutput`](crate::output::DescribeAffectedEntitiesOutput)
    pub fn builder() -> crate::output::describe_affected_entities_output::Builder {
        crate::output::describe_affected_entities_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeAffectedAccountsForOrganizationOutput {
    /// <p>A JSON set of elements of the affected accounts.</p>
    pub affected_accounts: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>This parameter specifies if the AWS Health event is a public AWS service event or an account-specific event.</p>
    /// <ul>
    /// <li>
    /// <p>If the <code>eventScopeCode</code> value is <code>PUBLIC</code>, then the
    /// <code>affectedAccounts</code> value is always empty.</p>
    /// </li>
    /// <li>
    /// <p>If the <code>eventScopeCode</code> value is <code>ACCOUNT_SPECIFIC</code>, then
    /// the <code>affectedAccounts</code> value lists the affected AWS accounts in your
    /// organization. For example, if an event affects a service such as Amazon Elastic Compute Cloud and you
    /// have AWS accounts that use that service, those account IDs appear in the
    /// response.</p>
    /// </li>
    /// <li>
    /// <p>If the <code>eventScopeCode</code> value is <code>NONE</code>, then the
    /// <code>eventArn</code> that you specified in the request is invalid or doesn't
    /// exist.</p>
    /// </li>
    /// </ul>
    pub event_scope_code: std::option::Option<crate::model::EventScopeCode>,
    /// <p>If the results of a search are large, only a portion of the
    /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
    /// retrieve the next batch of results, reissue the search request and include the returned token.
    /// When all results have been returned, the response does not contain a pagination token value.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeAffectedAccountsForOrganizationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeAffectedAccountsForOrganizationOutput");
        formatter.field("affected_accounts", &self.affected_accounts);
        formatter.field("event_scope_code", &self.event_scope_code);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeAffectedAccountsForOrganizationOutput`](crate::output::DescribeAffectedAccountsForOrganizationOutput)
pub mod describe_affected_accounts_for_organization_output {
    /// A builder for [`DescribeAffectedAccountsForOrganizationOutput`](crate::output::DescribeAffectedAccountsForOrganizationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) affected_accounts: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) event_scope_code: std::option::Option<crate::model::EventScopeCode>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn affected_accounts(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.affected_accounts.unwrap_or_default();
            v.push(input.into());
            self.affected_accounts = Some(v);
            self
        }
        pub fn set_affected_accounts(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.affected_accounts = input;
            self
        }
        /// <p>This parameter specifies if the AWS Health event is a public AWS service event or an account-specific event.</p>
        /// <ul>
        /// <li>
        /// <p>If the <code>eventScopeCode</code> value is <code>PUBLIC</code>, then the
        /// <code>affectedAccounts</code> value is always empty.</p>
        /// </li>
        /// <li>
        /// <p>If the <code>eventScopeCode</code> value is <code>ACCOUNT_SPECIFIC</code>, then
        /// the <code>affectedAccounts</code> value lists the affected AWS accounts in your
        /// organization. For example, if an event affects a service such as Amazon Elastic Compute Cloud and you
        /// have AWS accounts that use that service, those account IDs appear in the
        /// response.</p>
        /// </li>
        /// <li>
        /// <p>If the <code>eventScopeCode</code> value is <code>NONE</code>, then the
        /// <code>eventArn</code> that you specified in the request is invalid or doesn't
        /// exist.</p>
        /// </li>
        /// </ul>
        pub fn event_scope_code(mut self, input: crate::model::EventScopeCode) -> Self {
            self.event_scope_code = Some(input);
            self
        }
        pub fn set_event_scope_code(
            mut self,
            input: std::option::Option<crate::model::EventScopeCode>,
        ) -> Self {
            self.event_scope_code = input;
            self
        }
        /// <p>If the results of a search are large, only a portion of the
        /// results are returned, and a <code>nextToken</code> pagination token is returned in the response. To
        /// retrieve the next batch of results, reissue the search request and include the returned token.
        /// When all results have been returned, the response does not contain a pagination token value.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`DescribeAffectedAccountsForOrganizationOutput`](crate::output::DescribeAffectedAccountsForOrganizationOutput)
        pub fn build(self) -> crate::output::DescribeAffectedAccountsForOrganizationOutput {
            crate::output::DescribeAffectedAccountsForOrganizationOutput {
                affected_accounts: self.affected_accounts,
                event_scope_code: self.event_scope_code,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeAffectedAccountsForOrganizationOutput {
    /// Creates a new builder-style object to manufacture [`DescribeAffectedAccountsForOrganizationOutput`](crate::output::DescribeAffectedAccountsForOrganizationOutput)
    pub fn builder() -> crate::output::describe_affected_accounts_for_organization_output::Builder {
        crate::output::describe_affected_accounts_for_organization_output::Builder::default()
    }
}