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

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

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StopQueryOutput {
    /// <p>This is true if the query was stopped by the <code>StopQuery</code> operation.</p>
    pub success: bool,
}
impl std::fmt::Debug for StopQueryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StopQueryOutput");
        formatter.field("success", &self.success);
        formatter.finish()
    }
}
/// See [`StopQueryOutput`](crate::output::StopQueryOutput)
pub mod stop_query_output {
    /// A builder for [`StopQueryOutput`](crate::output::StopQueryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) success: std::option::Option<bool>,
    }
    impl Builder {
        /// <p>This is true if the query was stopped by the <code>StopQuery</code> operation.</p>
        pub fn success(mut self, input: bool) -> Self {
            self.success = Some(input);
            self
        }
        pub fn set_success(mut self, input: std::option::Option<bool>) -> Self {
            self.success = input;
            self
        }
        /// Consumes the builder and constructs a [`StopQueryOutput`](crate::output::StopQueryOutput)
        pub fn build(self) -> crate::output::StopQueryOutput {
            crate::output::StopQueryOutput {
                success: self.success.unwrap_or_default(),
            }
        }
    }
}
impl StopQueryOutput {
    /// Creates a new builder-style object to manufacture [`StopQueryOutput`](crate::output::StopQueryOutput)
    pub fn builder() -> crate::output::stop_query_output::Builder {
        crate::output::stop_query_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct StartQueryOutput {
    /// <p>The unique ID of the query. </p>
    pub query_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for StartQueryOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("StartQueryOutput");
        formatter.field("query_id", &self.query_id);
        formatter.finish()
    }
}
/// See [`StartQueryOutput`](crate::output::StartQueryOutput)
pub mod start_query_output {
    /// A builder for [`StartQueryOutput`](crate::output::StartQueryOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) query_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The unique ID of the query. </p>
        pub fn query_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.query_id = Some(input.into());
            self
        }
        pub fn set_query_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.query_id = input;
            self
        }
        /// Consumes the builder and constructs a [`StartQueryOutput`](crate::output::StartQueryOutput)
        pub fn build(self) -> crate::output::StartQueryOutput {
            crate::output::StartQueryOutput {
                query_id: self.query_id,
            }
        }
    }
}
impl StartQueryOutput {
    /// Creates a new builder-style object to manufacture [`StartQueryOutput`](crate::output::StartQueryOutput)
    pub fn builder() -> crate::output::start_query_output::Builder {
        crate::output::start_query_output::Builder::default()
    }
}

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

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutResourcePolicyOutput {
    /// <p>The new policy.</p>
    pub resource_policy: std::option::Option<crate::model::ResourcePolicy>,
}
impl std::fmt::Debug for PutResourcePolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutResourcePolicyOutput");
        formatter.field("resource_policy", &self.resource_policy);
        formatter.finish()
    }
}
/// See [`PutResourcePolicyOutput`](crate::output::PutResourcePolicyOutput)
pub mod put_resource_policy_output {
    /// A builder for [`PutResourcePolicyOutput`](crate::output::PutResourcePolicyOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resource_policy: std::option::Option<crate::model::ResourcePolicy>,
    }
    impl Builder {
        /// <p>The new policy.</p>
        pub fn resource_policy(mut self, input: crate::model::ResourcePolicy) -> Self {
            self.resource_policy = Some(input);
            self
        }
        pub fn set_resource_policy(
            mut self,
            input: std::option::Option<crate::model::ResourcePolicy>,
        ) -> Self {
            self.resource_policy = input;
            self
        }
        /// Consumes the builder and constructs a [`PutResourcePolicyOutput`](crate::output::PutResourcePolicyOutput)
        pub fn build(self) -> crate::output::PutResourcePolicyOutput {
            crate::output::PutResourcePolicyOutput {
                resource_policy: self.resource_policy,
            }
        }
    }
}
impl PutResourcePolicyOutput {
    /// Creates a new builder-style object to manufacture [`PutResourcePolicyOutput`](crate::output::PutResourcePolicyOutput)
    pub fn builder() -> crate::output::put_resource_policy_output::Builder {
        crate::output::put_resource_policy_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutQueryDefinitionOutput {
    /// <p>The ID of the query definition.</p>
    pub query_definition_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for PutQueryDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutQueryDefinitionOutput");
        formatter.field("query_definition_id", &self.query_definition_id);
        formatter.finish()
    }
}
/// See [`PutQueryDefinitionOutput`](crate::output::PutQueryDefinitionOutput)
pub mod put_query_definition_output {
    /// A builder for [`PutQueryDefinitionOutput`](crate::output::PutQueryDefinitionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) query_definition_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ID of the query definition.</p>
        pub fn query_definition_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.query_definition_id = Some(input.into());
            self
        }
        pub fn set_query_definition_id(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.query_definition_id = input;
            self
        }
        /// Consumes the builder and constructs a [`PutQueryDefinitionOutput`](crate::output::PutQueryDefinitionOutput)
        pub fn build(self) -> crate::output::PutQueryDefinitionOutput {
            crate::output::PutQueryDefinitionOutput {
                query_definition_id: self.query_definition_id,
            }
        }
    }
}
impl PutQueryDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`PutQueryDefinitionOutput`](crate::output::PutQueryDefinitionOutput)
    pub fn builder() -> crate::output::put_query_definition_output::Builder {
        crate::output::put_query_definition_output::Builder::default()
    }
}

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutLogEventsOutput {
    /// <p>The next sequence token.</p>
    pub next_sequence_token: std::option::Option<std::string::String>,
    /// <p>The rejected events.</p>
    pub rejected_log_events_info: std::option::Option<crate::model::RejectedLogEventsInfo>,
}
impl std::fmt::Debug for PutLogEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutLogEventsOutput");
        formatter.field("next_sequence_token", &self.next_sequence_token);
        formatter.field("rejected_log_events_info", &self.rejected_log_events_info);
        formatter.finish()
    }
}
/// See [`PutLogEventsOutput`](crate::output::PutLogEventsOutput)
pub mod put_log_events_output {
    /// A builder for [`PutLogEventsOutput`](crate::output::PutLogEventsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) next_sequence_token: std::option::Option<std::string::String>,
        pub(crate) rejected_log_events_info:
            std::option::Option<crate::model::RejectedLogEventsInfo>,
    }
    impl Builder {
        /// <p>The next sequence token.</p>
        pub fn next_sequence_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_sequence_token = Some(input.into());
            self
        }
        pub fn set_next_sequence_token(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.next_sequence_token = input;
            self
        }
        /// <p>The rejected events.</p>
        pub fn rejected_log_events_info(
            mut self,
            input: crate::model::RejectedLogEventsInfo,
        ) -> Self {
            self.rejected_log_events_info = Some(input);
            self
        }
        pub fn set_rejected_log_events_info(
            mut self,
            input: std::option::Option<crate::model::RejectedLogEventsInfo>,
        ) -> Self {
            self.rejected_log_events_info = input;
            self
        }
        /// Consumes the builder and constructs a [`PutLogEventsOutput`](crate::output::PutLogEventsOutput)
        pub fn build(self) -> crate::output::PutLogEventsOutput {
            crate::output::PutLogEventsOutput {
                next_sequence_token: self.next_sequence_token,
                rejected_log_events_info: self.rejected_log_events_info,
            }
        }
    }
}
impl PutLogEventsOutput {
    /// Creates a new builder-style object to manufacture [`PutLogEventsOutput`](crate::output::PutLogEventsOutput)
    pub fn builder() -> crate::output::put_log_events_output::Builder {
        crate::output::put_log_events_output::Builder::default()
    }
}

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

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsLogGroupOutput {
    /// <p>The tags for the log group.</p>
    pub tags:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for ListTagsLogGroupOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsLogGroupOutput");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`ListTagsLogGroupOutput`](crate::output::ListTagsLogGroupOutput)
pub mod list_tags_log_group_output {
    /// A builder for [`ListTagsLogGroupOutput`](crate::output::ListTagsLogGroupOutput)
    #[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 {
        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
        }
        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 [`ListTagsLogGroupOutput`](crate::output::ListTagsLogGroupOutput)
        pub fn build(self) -> crate::output::ListTagsLogGroupOutput {
            crate::output::ListTagsLogGroupOutput { tags: self.tags }
        }
    }
}
impl ListTagsLogGroupOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsLogGroupOutput`](crate::output::ListTagsLogGroupOutput)
    pub fn builder() -> crate::output::list_tags_log_group_output::Builder {
        crate::output::list_tags_log_group_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetQueryResultsOutput {
    /// <p>The log events that matched the query criteria during the most recent time it ran.</p>
    /// <p>The <code>results</code> value is an array of arrays. Each log event is one object in the
    /// top-level array. Each of these log event objects is an array of
    /// <code>field</code>/<code>value</code> pairs.</p>
    pub results: std::option::Option<std::vec::Vec<std::vec::Vec<crate::model::ResultField>>>,
    /// <p>Includes the number of log events scanned by the query, the number of log events that matched the
    /// query criteria, and the total number of bytes in the log events that were scanned. These values
    /// reflect the full raw results of the query.</p>
    pub statistics: std::option::Option<crate::model::QueryStatistics>,
    /// <p>The status of the most recent running of the query. Possible values are <code>Cancelled</code>,
    /// <code>Complete</code>, <code>Failed</code>, <code>Running</code>, <code>Scheduled</code>,
    /// <code>Timeout</code>, and <code>Unknown</code>.</p>
    /// <p>Queries time out after 15 minutes of execution. To avoid having your queries time out,
    /// reduce the time range being searched or partition your query into a number of queries.</p>
    pub status: std::option::Option<crate::model::QueryStatus>,
}
impl std::fmt::Debug for GetQueryResultsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetQueryResultsOutput");
        formatter.field("results", &self.results);
        formatter.field("statistics", &self.statistics);
        formatter.field("status", &self.status);
        formatter.finish()
    }
}
/// See [`GetQueryResultsOutput`](crate::output::GetQueryResultsOutput)
pub mod get_query_results_output {
    /// A builder for [`GetQueryResultsOutput`](crate::output::GetQueryResultsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) results:
            std::option::Option<std::vec::Vec<std::vec::Vec<crate::model::ResultField>>>,
        pub(crate) statistics: std::option::Option<crate::model::QueryStatistics>,
        pub(crate) status: std::option::Option<crate::model::QueryStatus>,
    }
    impl Builder {
        pub fn results(
            mut self,
            input: impl Into<std::vec::Vec<crate::model::ResultField>>,
        ) -> Self {
            let mut v = self.results.unwrap_or_default();
            v.push(input.into());
            self.results = Some(v);
            self
        }
        pub fn set_results(
            mut self,
            input: std::option::Option<std::vec::Vec<std::vec::Vec<crate::model::ResultField>>>,
        ) -> Self {
            self.results = input;
            self
        }
        /// <p>Includes the number of log events scanned by the query, the number of log events that matched the
        /// query criteria, and the total number of bytes in the log events that were scanned. These values
        /// reflect the full raw results of the query.</p>
        pub fn statistics(mut self, input: crate::model::QueryStatistics) -> Self {
            self.statistics = Some(input);
            self
        }
        pub fn set_statistics(
            mut self,
            input: std::option::Option<crate::model::QueryStatistics>,
        ) -> Self {
            self.statistics = input;
            self
        }
        /// <p>The status of the most recent running of the query. Possible values are <code>Cancelled</code>,
        /// <code>Complete</code>, <code>Failed</code>, <code>Running</code>, <code>Scheduled</code>,
        /// <code>Timeout</code>, and <code>Unknown</code>.</p>
        /// <p>Queries time out after 15 minutes of execution. To avoid having your queries time out,
        /// reduce the time range being searched or partition your query into a number of queries.</p>
        pub fn status(mut self, input: crate::model::QueryStatus) -> Self {
            self.status = Some(input);
            self
        }
        pub fn set_status(mut self, input: std::option::Option<crate::model::QueryStatus>) -> Self {
            self.status = input;
            self
        }
        /// Consumes the builder and constructs a [`GetQueryResultsOutput`](crate::output::GetQueryResultsOutput)
        pub fn build(self) -> crate::output::GetQueryResultsOutput {
            crate::output::GetQueryResultsOutput {
                results: self.results,
                statistics: self.statistics,
                status: self.status,
            }
        }
    }
}
impl GetQueryResultsOutput {
    /// Creates a new builder-style object to manufacture [`GetQueryResultsOutput`](crate::output::GetQueryResultsOutput)
    pub fn builder() -> crate::output::get_query_results_output::Builder {
        crate::output::get_query_results_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetLogRecordOutput {
    /// <p>The requested log event, as a JSON string.</p>
    pub log_record:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
}
impl std::fmt::Debug for GetLogRecordOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetLogRecordOutput");
        formatter.field("log_record", &self.log_record);
        formatter.finish()
    }
}
/// See [`GetLogRecordOutput`](crate::output::GetLogRecordOutput)
pub mod get_log_record_output {
    /// A builder for [`GetLogRecordOutput`](crate::output::GetLogRecordOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) log_record: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
    }
    impl Builder {
        pub fn log_record(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.log_record.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.log_record = Some(hash_map);
            self
        }
        pub fn set_log_record(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.log_record = input;
            self
        }
        /// Consumes the builder and constructs a [`GetLogRecordOutput`](crate::output::GetLogRecordOutput)
        pub fn build(self) -> crate::output::GetLogRecordOutput {
            crate::output::GetLogRecordOutput {
                log_record: self.log_record,
            }
        }
    }
}
impl GetLogRecordOutput {
    /// Creates a new builder-style object to manufacture [`GetLogRecordOutput`](crate::output::GetLogRecordOutput)
    pub fn builder() -> crate::output::get_log_record_output::Builder {
        crate::output::get_log_record_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetLogGroupFieldsOutput {
    /// <p>The array of fields found in the query. Each object in the array contains the name of the field, along with the
    /// percentage of time it appeared in the log events that were queried.</p>
    pub log_group_fields: std::option::Option<std::vec::Vec<crate::model::LogGroupField>>,
}
impl std::fmt::Debug for GetLogGroupFieldsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetLogGroupFieldsOutput");
        formatter.field("log_group_fields", &self.log_group_fields);
        formatter.finish()
    }
}
/// See [`GetLogGroupFieldsOutput`](crate::output::GetLogGroupFieldsOutput)
pub mod get_log_group_fields_output {
    /// A builder for [`GetLogGroupFieldsOutput`](crate::output::GetLogGroupFieldsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) log_group_fields:
            std::option::Option<std::vec::Vec<crate::model::LogGroupField>>,
    }
    impl Builder {
        pub fn log_group_fields(mut self, input: impl Into<crate::model::LogGroupField>) -> Self {
            let mut v = self.log_group_fields.unwrap_or_default();
            v.push(input.into());
            self.log_group_fields = Some(v);
            self
        }
        pub fn set_log_group_fields(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::LogGroupField>>,
        ) -> Self {
            self.log_group_fields = input;
            self
        }
        /// Consumes the builder and constructs a [`GetLogGroupFieldsOutput`](crate::output::GetLogGroupFieldsOutput)
        pub fn build(self) -> crate::output::GetLogGroupFieldsOutput {
            crate::output::GetLogGroupFieldsOutput {
                log_group_fields: self.log_group_fields,
            }
        }
    }
}
impl GetLogGroupFieldsOutput {
    /// Creates a new builder-style object to manufacture [`GetLogGroupFieldsOutput`](crate::output::GetLogGroupFieldsOutput)
    pub fn builder() -> crate::output::get_log_group_fields_output::Builder {
        crate::output::get_log_group_fields_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetLogEventsOutput {
    /// <p>The events.</p>
    pub events: std::option::Option<std::vec::Vec<crate::model::OutputLogEvent>>,
    /// <p>The token for the next set of items in the forward direction. The token expires after
    /// 24 hours. If you have reached the end of the stream, it returns the same token you passed
    /// in.</p>
    pub next_forward_token: std::option::Option<std::string::String>,
    /// <p>The token for the next set of items in the backward direction. The token expires after
    /// 24 hours. This token is never null. If you have reached the end of the stream, it returns the
    /// same token you passed in.</p>
    pub next_backward_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for GetLogEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetLogEventsOutput");
        formatter.field("events", &self.events);
        formatter.field("next_forward_token", &self.next_forward_token);
        formatter.field("next_backward_token", &self.next_backward_token);
        formatter.finish()
    }
}
/// See [`GetLogEventsOutput`](crate::output::GetLogEventsOutput)
pub mod get_log_events_output {
    /// A builder for [`GetLogEventsOutput`](crate::output::GetLogEventsOutput)
    #[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::OutputLogEvent>>,
        pub(crate) next_forward_token: std::option::Option<std::string::String>,
        pub(crate) next_backward_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn events(mut self, input: impl Into<crate::model::OutputLogEvent>) -> 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::OutputLogEvent>>,
        ) -> Self {
            self.events = input;
            self
        }
        /// <p>The token for the next set of items in the forward direction. The token expires after
        /// 24 hours. If you have reached the end of the stream, it returns the same token you passed
        /// in.</p>
        pub fn next_forward_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_forward_token = Some(input.into());
            self
        }
        pub fn set_next_forward_token(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.next_forward_token = input;
            self
        }
        /// <p>The token for the next set of items in the backward direction. The token expires after
        /// 24 hours. This token is never null. If you have reached the end of the stream, it returns the
        /// same token you passed in.</p>
        pub fn next_backward_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_backward_token = Some(input.into());
            self
        }
        pub fn set_next_backward_token(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.next_backward_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetLogEventsOutput`](crate::output::GetLogEventsOutput)
        pub fn build(self) -> crate::output::GetLogEventsOutput {
            crate::output::GetLogEventsOutput {
                events: self.events,
                next_forward_token: self.next_forward_token,
                next_backward_token: self.next_backward_token,
            }
        }
    }
}
impl GetLogEventsOutput {
    /// Creates a new builder-style object to manufacture [`GetLogEventsOutput`](crate::output::GetLogEventsOutput)
    pub fn builder() -> crate::output::get_log_events_output::Builder {
        crate::output::get_log_events_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct FilterLogEventsOutput {
    /// <p>The matched events.</p>
    pub events: std::option::Option<std::vec::Vec<crate::model::FilteredLogEvent>>,
    /// <p>
    /// <b>IMPORTANT</b> Starting on May 15, 2020,
    /// this parameter will be deprecated. This parameter will be an empty list
    /// after the deprecation occurs.</p>
    /// <p>Indicates which log streams have been searched and whether each has been searched completely.</p>
    pub searched_log_streams: std::option::Option<std::vec::Vec<crate::model::SearchedLogStream>>,
    /// <p>The token to use when requesting the next set of items. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for FilterLogEventsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("FilterLogEventsOutput");
        formatter.field("events", &self.events);
        formatter.field("searched_log_streams", &self.searched_log_streams);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`FilterLogEventsOutput`](crate::output::FilterLogEventsOutput)
pub mod filter_log_events_output {
    /// A builder for [`FilterLogEventsOutput`](crate::output::FilterLogEventsOutput)
    #[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::FilteredLogEvent>>,
        pub(crate) searched_log_streams:
            std::option::Option<std::vec::Vec<crate::model::SearchedLogStream>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn events(mut self, input: impl Into<crate::model::FilteredLogEvent>) -> 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::FilteredLogEvent>>,
        ) -> Self {
            self.events = input;
            self
        }
        pub fn searched_log_streams(
            mut self,
            input: impl Into<crate::model::SearchedLogStream>,
        ) -> Self {
            let mut v = self.searched_log_streams.unwrap_or_default();
            v.push(input.into());
            self.searched_log_streams = Some(v);
            self
        }
        pub fn set_searched_log_streams(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SearchedLogStream>>,
        ) -> Self {
            self.searched_log_streams = input;
            self
        }
        /// <p>The token to use when requesting the next set of items. The token expires after 24 hours.</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 [`FilterLogEventsOutput`](crate::output::FilterLogEventsOutput)
        pub fn build(self) -> crate::output::FilterLogEventsOutput {
            crate::output::FilterLogEventsOutput {
                events: self.events,
                searched_log_streams: self.searched_log_streams,
                next_token: self.next_token,
            }
        }
    }
}
impl FilterLogEventsOutput {
    /// Creates a new builder-style object to manufacture [`FilterLogEventsOutput`](crate::output::FilterLogEventsOutput)
    pub fn builder() -> crate::output::filter_log_events_output::Builder {
        crate::output::filter_log_events_output::Builder::default()
    }
}

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeSubscriptionFiltersOutput {
    /// <p>The subscription filters.</p>
    pub subscription_filters: std::option::Option<std::vec::Vec<crate::model::SubscriptionFilter>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeSubscriptionFiltersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeSubscriptionFiltersOutput");
        formatter.field("subscription_filters", &self.subscription_filters);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeSubscriptionFiltersOutput`](crate::output::DescribeSubscriptionFiltersOutput)
pub mod describe_subscription_filters_output {
    /// A builder for [`DescribeSubscriptionFiltersOutput`](crate::output::DescribeSubscriptionFiltersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) subscription_filters:
            std::option::Option<std::vec::Vec<crate::model::SubscriptionFilter>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn subscription_filters(
            mut self,
            input: impl Into<crate::model::SubscriptionFilter>,
        ) -> Self {
            let mut v = self.subscription_filters.unwrap_or_default();
            v.push(input.into());
            self.subscription_filters = Some(v);
            self
        }
        pub fn set_subscription_filters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SubscriptionFilter>>,
        ) -> Self {
            self.subscription_filters = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeSubscriptionFiltersOutput`](crate::output::DescribeSubscriptionFiltersOutput)
        pub fn build(self) -> crate::output::DescribeSubscriptionFiltersOutput {
            crate::output::DescribeSubscriptionFiltersOutput {
                subscription_filters: self.subscription_filters,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeSubscriptionFiltersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeSubscriptionFiltersOutput`](crate::output::DescribeSubscriptionFiltersOutput)
    pub fn builder() -> crate::output::describe_subscription_filters_output::Builder {
        crate::output::describe_subscription_filters_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeResourcePoliciesOutput {
    /// <p>The resource policies that exist in this account.</p>
    pub resource_policies: std::option::Option<std::vec::Vec<crate::model::ResourcePolicy>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeResourcePoliciesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeResourcePoliciesOutput");
        formatter.field("resource_policies", &self.resource_policies);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeResourcePoliciesOutput`](crate::output::DescribeResourcePoliciesOutput)
pub mod describe_resource_policies_output {
    /// A builder for [`DescribeResourcePoliciesOutput`](crate::output::DescribeResourcePoliciesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) resource_policies:
            std::option::Option<std::vec::Vec<crate::model::ResourcePolicy>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn resource_policies(mut self, input: impl Into<crate::model::ResourcePolicy>) -> Self {
            let mut v = self.resource_policies.unwrap_or_default();
            v.push(input.into());
            self.resource_policies = Some(v);
            self
        }
        pub fn set_resource_policies(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ResourcePolicy>>,
        ) -> Self {
            self.resource_policies = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeResourcePoliciesOutput`](crate::output::DescribeResourcePoliciesOutput)
        pub fn build(self) -> crate::output::DescribeResourcePoliciesOutput {
            crate::output::DescribeResourcePoliciesOutput {
                resource_policies: self.resource_policies,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeResourcePoliciesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeResourcePoliciesOutput`](crate::output::DescribeResourcePoliciesOutput)
    pub fn builder() -> crate::output::describe_resource_policies_output::Builder {
        crate::output::describe_resource_policies_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeQueryDefinitionsOutput {
    /// <p>The list of query definitions that match your request.</p>
    pub query_definitions: std::option::Option<std::vec::Vec<crate::model::QueryDefinition>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeQueryDefinitionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeQueryDefinitionsOutput");
        formatter.field("query_definitions", &self.query_definitions);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeQueryDefinitionsOutput`](crate::output::DescribeQueryDefinitionsOutput)
pub mod describe_query_definitions_output {
    /// A builder for [`DescribeQueryDefinitionsOutput`](crate::output::DescribeQueryDefinitionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) query_definitions:
            std::option::Option<std::vec::Vec<crate::model::QueryDefinition>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn query_definitions(
            mut self,
            input: impl Into<crate::model::QueryDefinition>,
        ) -> Self {
            let mut v = self.query_definitions.unwrap_or_default();
            v.push(input.into());
            self.query_definitions = Some(v);
            self
        }
        pub fn set_query_definitions(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::QueryDefinition>>,
        ) -> Self {
            self.query_definitions = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeQueryDefinitionsOutput`](crate::output::DescribeQueryDefinitionsOutput)
        pub fn build(self) -> crate::output::DescribeQueryDefinitionsOutput {
            crate::output::DescribeQueryDefinitionsOutput {
                query_definitions: self.query_definitions,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeQueryDefinitionsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeQueryDefinitionsOutput`](crate::output::DescribeQueryDefinitionsOutput)
    pub fn builder() -> crate::output::describe_query_definitions_output::Builder {
        crate::output::describe_query_definitions_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeQueriesOutput {
    /// <p>The list of queries that match the request.</p>
    pub queries: std::option::Option<std::vec::Vec<crate::model::QueryInfo>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeQueriesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeQueriesOutput");
        formatter.field("queries", &self.queries);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeQueriesOutput`](crate::output::DescribeQueriesOutput)
pub mod describe_queries_output {
    /// A builder for [`DescribeQueriesOutput`](crate::output::DescribeQueriesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) queries: std::option::Option<std::vec::Vec<crate::model::QueryInfo>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn queries(mut self, input: impl Into<crate::model::QueryInfo>) -> Self {
            let mut v = self.queries.unwrap_or_default();
            v.push(input.into());
            self.queries = Some(v);
            self
        }
        pub fn set_queries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::QueryInfo>>,
        ) -> Self {
            self.queries = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeQueriesOutput`](crate::output::DescribeQueriesOutput)
        pub fn build(self) -> crate::output::DescribeQueriesOutput {
            crate::output::DescribeQueriesOutput {
                queries: self.queries,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeQueriesOutput {
    /// Creates a new builder-style object to manufacture [`DescribeQueriesOutput`](crate::output::DescribeQueriesOutput)
    pub fn builder() -> crate::output::describe_queries_output::Builder {
        crate::output::describe_queries_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeMetricFiltersOutput {
    /// <p>The metric filters.</p>
    pub metric_filters: std::option::Option<std::vec::Vec<crate::model::MetricFilter>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeMetricFiltersOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeMetricFiltersOutput");
        formatter.field("metric_filters", &self.metric_filters);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeMetricFiltersOutput`](crate::output::DescribeMetricFiltersOutput)
pub mod describe_metric_filters_output {
    /// A builder for [`DescribeMetricFiltersOutput`](crate::output::DescribeMetricFiltersOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) metric_filters: std::option::Option<std::vec::Vec<crate::model::MetricFilter>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn metric_filters(mut self, input: impl Into<crate::model::MetricFilter>) -> Self {
            let mut v = self.metric_filters.unwrap_or_default();
            v.push(input.into());
            self.metric_filters = Some(v);
            self
        }
        pub fn set_metric_filters(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::MetricFilter>>,
        ) -> Self {
            self.metric_filters = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeMetricFiltersOutput`](crate::output::DescribeMetricFiltersOutput)
        pub fn build(self) -> crate::output::DescribeMetricFiltersOutput {
            crate::output::DescribeMetricFiltersOutput {
                metric_filters: self.metric_filters,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeMetricFiltersOutput {
    /// Creates a new builder-style object to manufacture [`DescribeMetricFiltersOutput`](crate::output::DescribeMetricFiltersOutput)
    pub fn builder() -> crate::output::describe_metric_filters_output::Builder {
        crate::output::describe_metric_filters_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeLogStreamsOutput {
    /// <p>The log streams.</p>
    pub log_streams: std::option::Option<std::vec::Vec<crate::model::LogStream>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeLogStreamsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeLogStreamsOutput");
        formatter.field("log_streams", &self.log_streams);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeLogStreamsOutput`](crate::output::DescribeLogStreamsOutput)
pub mod describe_log_streams_output {
    /// A builder for [`DescribeLogStreamsOutput`](crate::output::DescribeLogStreamsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) log_streams: std::option::Option<std::vec::Vec<crate::model::LogStream>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn log_streams(mut self, input: impl Into<crate::model::LogStream>) -> Self {
            let mut v = self.log_streams.unwrap_or_default();
            v.push(input.into());
            self.log_streams = Some(v);
            self
        }
        pub fn set_log_streams(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::LogStream>>,
        ) -> Self {
            self.log_streams = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeLogStreamsOutput`](crate::output::DescribeLogStreamsOutput)
        pub fn build(self) -> crate::output::DescribeLogStreamsOutput {
            crate::output::DescribeLogStreamsOutput {
                log_streams: self.log_streams,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeLogStreamsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeLogStreamsOutput`](crate::output::DescribeLogStreamsOutput)
    pub fn builder() -> crate::output::describe_log_streams_output::Builder {
        crate::output::describe_log_streams_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeLogGroupsOutput {
    /// <p>The log groups.</p>
    /// <p>If the <code>retentionInDays</code> value if not included for a log group, then that log group
    /// is set to have its events never expire.</p>
    pub log_groups: std::option::Option<std::vec::Vec<crate::model::LogGroup>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeLogGroupsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeLogGroupsOutput");
        formatter.field("log_groups", &self.log_groups);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeLogGroupsOutput`](crate::output::DescribeLogGroupsOutput)
pub mod describe_log_groups_output {
    /// A builder for [`DescribeLogGroupsOutput`](crate::output::DescribeLogGroupsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) log_groups: std::option::Option<std::vec::Vec<crate::model::LogGroup>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn log_groups(mut self, input: impl Into<crate::model::LogGroup>) -> Self {
            let mut v = self.log_groups.unwrap_or_default();
            v.push(input.into());
            self.log_groups = Some(v);
            self
        }
        pub fn set_log_groups(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::LogGroup>>,
        ) -> Self {
            self.log_groups = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeLogGroupsOutput`](crate::output::DescribeLogGroupsOutput)
        pub fn build(self) -> crate::output::DescribeLogGroupsOutput {
            crate::output::DescribeLogGroupsOutput {
                log_groups: self.log_groups,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeLogGroupsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeLogGroupsOutput`](crate::output::DescribeLogGroupsOutput)
    pub fn builder() -> crate::output::describe_log_groups_output::Builder {
        crate::output::describe_log_groups_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeExportTasksOutput {
    /// <p>The export tasks.</p>
    pub export_tasks: std::option::Option<std::vec::Vec<crate::model::ExportTask>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeExportTasksOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeExportTasksOutput");
        formatter.field("export_tasks", &self.export_tasks);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeExportTasksOutput`](crate::output::DescribeExportTasksOutput)
pub mod describe_export_tasks_output {
    /// A builder for [`DescribeExportTasksOutput`](crate::output::DescribeExportTasksOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) export_tasks: std::option::Option<std::vec::Vec<crate::model::ExportTask>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn export_tasks(mut self, input: impl Into<crate::model::ExportTask>) -> Self {
            let mut v = self.export_tasks.unwrap_or_default();
            v.push(input.into());
            self.export_tasks = Some(v);
            self
        }
        pub fn set_export_tasks(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ExportTask>>,
        ) -> Self {
            self.export_tasks = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeExportTasksOutput`](crate::output::DescribeExportTasksOutput)
        pub fn build(self) -> crate::output::DescribeExportTasksOutput {
            crate::output::DescribeExportTasksOutput {
                export_tasks: self.export_tasks,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeExportTasksOutput {
    /// Creates a new builder-style object to manufacture [`DescribeExportTasksOutput`](crate::output::DescribeExportTasksOutput)
    pub fn builder() -> crate::output::describe_export_tasks_output::Builder {
        crate::output::describe_export_tasks_output::Builder::default()
    }
}

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DescribeDestinationsOutput {
    /// <p>The destinations.</p>
    pub destinations: std::option::Option<std::vec::Vec<crate::model::Destination>>,
    /// <p>The token for the next set of items to return. The token expires after 24 hours.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for DescribeDestinationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DescribeDestinationsOutput");
        formatter.field("destinations", &self.destinations);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`DescribeDestinationsOutput`](crate::output::DescribeDestinationsOutput)
pub mod describe_destinations_output {
    /// A builder for [`DescribeDestinationsOutput`](crate::output::DescribeDestinationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) destinations: std::option::Option<std::vec::Vec<crate::model::Destination>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        pub fn destinations(mut self, input: impl Into<crate::model::Destination>) -> Self {
            let mut v = self.destinations.unwrap_or_default();
            v.push(input.into());
            self.destinations = Some(v);
            self
        }
        pub fn set_destinations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Destination>>,
        ) -> Self {
            self.destinations = input;
            self
        }
        /// <p>The token for the next set of items to return. The token expires after 24 hours.</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 [`DescribeDestinationsOutput`](crate::output::DescribeDestinationsOutput)
        pub fn build(self) -> crate::output::DescribeDestinationsOutput {
            crate::output::DescribeDestinationsOutput {
                destinations: self.destinations,
                next_token: self.next_token,
            }
        }
    }
}
impl DescribeDestinationsOutput {
    /// Creates a new builder-style object to manufacture [`DescribeDestinationsOutput`](crate::output::DescribeDestinationsOutput)
    pub fn builder() -> crate::output::describe_destinations_output::Builder {
        crate::output::describe_destinations_output::Builder::default()
    }
}

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

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

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteQueryDefinitionOutput {
    /// <p>A value of TRUE indicates that the operation succeeded. FALSE indicates that the operation
    /// failed.</p>
    pub success: bool,
}
impl std::fmt::Debug for DeleteQueryDefinitionOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteQueryDefinitionOutput");
        formatter.field("success", &self.success);
        formatter.finish()
    }
}
/// See [`DeleteQueryDefinitionOutput`](crate::output::DeleteQueryDefinitionOutput)
pub mod delete_query_definition_output {
    /// A builder for [`DeleteQueryDefinitionOutput`](crate::output::DeleteQueryDefinitionOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) success: std::option::Option<bool>,
    }
    impl Builder {
        /// <p>A value of TRUE indicates that the operation succeeded. FALSE indicates that the operation
        /// failed.</p>
        pub fn success(mut self, input: bool) -> Self {
            self.success = Some(input);
            self
        }
        pub fn set_success(mut self, input: std::option::Option<bool>) -> Self {
            self.success = input;
            self
        }
        /// Consumes the builder and constructs a [`DeleteQueryDefinitionOutput`](crate::output::DeleteQueryDefinitionOutput)
        pub fn build(self) -> crate::output::DeleteQueryDefinitionOutput {
            crate::output::DeleteQueryDefinitionOutput {
                success: self.success.unwrap_or_default(),
            }
        }
    }
}
impl DeleteQueryDefinitionOutput {
    /// Creates a new builder-style object to manufacture [`DeleteQueryDefinitionOutput`](crate::output::DeleteQueryDefinitionOutput)
    pub fn builder() -> crate::output::delete_query_definition_output::Builder {
        crate::output::delete_query_definition_output::Builder::default()
    }
}

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

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

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

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

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

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

#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateExportTaskOutput {
    /// <p>The ID of the export task.</p>
    pub task_id: std::option::Option<std::string::String>,
}
impl std::fmt::Debug for CreateExportTaskOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateExportTaskOutput");
        formatter.field("task_id", &self.task_id);
        formatter.finish()
    }
}
/// See [`CreateExportTaskOutput`](crate::output::CreateExportTaskOutput)
pub mod create_export_task_output {
    /// A builder for [`CreateExportTaskOutput`](crate::output::CreateExportTaskOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) task_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The ID of the export task.</p>
        pub fn task_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.task_id = Some(input.into());
            self
        }
        pub fn set_task_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.task_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateExportTaskOutput`](crate::output::CreateExportTaskOutput)
        pub fn build(self) -> crate::output::CreateExportTaskOutput {
            crate::output::CreateExportTaskOutput {
                task_id: self.task_id,
            }
        }
    }
}
impl CreateExportTaskOutput {
    /// Creates a new builder-style object to manufacture [`CreateExportTaskOutput`](crate::output::CreateExportTaskOutput)
    pub fn builder() -> crate::output::create_export_task_output::Builder {
        crate::output::create_export_task_output::Builder::default()
    }
}

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

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