// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateEmailTemplateOutput {}
impl std::fmt::Debug for UpdateEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`UpdateEmailTemplateOutput`](crate::output::UpdateEmailTemplateOutput)
pub mod update_email_template_output {
    /// A builder for [`UpdateEmailTemplateOutput`](crate::output::UpdateEmailTemplateOutput)
    #[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 [`UpdateEmailTemplateOutput`](crate::output::UpdateEmailTemplateOutput)
        pub fn build(self) -> crate::output::UpdateEmailTemplateOutput {
            crate::output::UpdateEmailTemplateOutput {}
        }
    }
}
impl UpdateEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEmailTemplateOutput`](crate::output::UpdateEmailTemplateOutput)
    pub fn builder() -> crate::output::update_email_template_output::Builder {
        crate::output::update_email_template_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateEmailIdentityPolicyOutput {}
impl std::fmt::Debug for UpdateEmailIdentityPolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateEmailIdentityPolicyOutput");
        formatter.finish()
    }
}
/// See [`UpdateEmailIdentityPolicyOutput`](crate::output::UpdateEmailIdentityPolicyOutput)
pub mod update_email_identity_policy_output {
    /// A builder for [`UpdateEmailIdentityPolicyOutput`](crate::output::UpdateEmailIdentityPolicyOutput)
    #[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 [`UpdateEmailIdentityPolicyOutput`](crate::output::UpdateEmailIdentityPolicyOutput)
        pub fn build(self) -> crate::output::UpdateEmailIdentityPolicyOutput {
            crate::output::UpdateEmailIdentityPolicyOutput {}
        }
    }
}
impl UpdateEmailIdentityPolicyOutput {
    /// Creates a new builder-style object to manufacture [`UpdateEmailIdentityPolicyOutput`](crate::output::UpdateEmailIdentityPolicyOutput)
    pub fn builder() -> crate::output::update_email_identity_policy_output::Builder {
        crate::output::update_email_identity_policy_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateCustomVerificationEmailTemplateOutput {}
impl std::fmt::Debug for UpdateCustomVerificationEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateCustomVerificationEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`UpdateCustomVerificationEmailTemplateOutput`](crate::output::UpdateCustomVerificationEmailTemplateOutput)
pub mod update_custom_verification_email_template_output {
    /// A builder for [`UpdateCustomVerificationEmailTemplateOutput`](crate::output::UpdateCustomVerificationEmailTemplateOutput)
    #[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 [`UpdateCustomVerificationEmailTemplateOutput`](crate::output::UpdateCustomVerificationEmailTemplateOutput)
        pub fn build(self) -> crate::output::UpdateCustomVerificationEmailTemplateOutput {
            crate::output::UpdateCustomVerificationEmailTemplateOutput {}
        }
    }
}
impl UpdateCustomVerificationEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`UpdateCustomVerificationEmailTemplateOutput`](crate::output::UpdateCustomVerificationEmailTemplateOutput)
    pub fn builder() -> crate::output::update_custom_verification_email_template_output::Builder {
        crate::output::update_custom_verification_email_template_output::Builder::default()
    }
}

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

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

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct UpdateConfigurationSetEventDestinationOutput {}
impl std::fmt::Debug for UpdateConfigurationSetEventDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("UpdateConfigurationSetEventDestinationOutput");
        formatter.finish()
    }
}
/// See [`UpdateConfigurationSetEventDestinationOutput`](crate::output::UpdateConfigurationSetEventDestinationOutput)
pub mod update_configuration_set_event_destination_output {
    /// A builder for [`UpdateConfigurationSetEventDestinationOutput`](crate::output::UpdateConfigurationSetEventDestinationOutput)
    #[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 [`UpdateConfigurationSetEventDestinationOutput`](crate::output::UpdateConfigurationSetEventDestinationOutput)
        pub fn build(self) -> crate::output::UpdateConfigurationSetEventDestinationOutput {
            crate::output::UpdateConfigurationSetEventDestinationOutput {}
        }
    }
}
impl UpdateConfigurationSetEventDestinationOutput {
    /// Creates a new builder-style object to manufacture [`UpdateConfigurationSetEventDestinationOutput`](crate::output::UpdateConfigurationSetEventDestinationOutput)
    pub fn builder() -> crate::output::update_configuration_set_event_destination_output::Builder {
        crate::output::update_configuration_set_event_destination_output::Builder::default()
    }
}

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

/// <p>The following element is returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct TestRenderEmailTemplateOutput {
    /// <p>The complete MIME message rendered by applying the data in the <code>TemplateData</code> parameter to the template specified in the TemplateName parameter.</p>
    pub rendered_template: std::option::Option<std::string::String>,
}
impl TestRenderEmailTemplateOutput {
    /// <p>The complete MIME message rendered by applying the data in the <code>TemplateData</code> parameter to the template specified in the TemplateName parameter.</p>
    pub fn rendered_template(&self) -> std::option::Option<&str> {
        self.rendered_template.as_deref()
    }
}
impl std::fmt::Debug for TestRenderEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("TestRenderEmailTemplateOutput");
        formatter.field("rendered_template", &self.rendered_template);
        formatter.finish()
    }
}
/// See [`TestRenderEmailTemplateOutput`](crate::output::TestRenderEmailTemplateOutput)
pub mod test_render_email_template_output {
    /// A builder for [`TestRenderEmailTemplateOutput`](crate::output::TestRenderEmailTemplateOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) rendered_template: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The complete MIME message rendered by applying the data in the <code>TemplateData</code> parameter to the template specified in the TemplateName parameter.</p>
        pub fn rendered_template(mut self, input: impl Into<std::string::String>) -> Self {
            self.rendered_template = Some(input.into());
            self
        }
        /// <p>The complete MIME message rendered by applying the data in the <code>TemplateData</code> parameter to the template specified in the TemplateName parameter.</p>
        pub fn set_rendered_template(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.rendered_template = input;
            self
        }
        /// Consumes the builder and constructs a [`TestRenderEmailTemplateOutput`](crate::output::TestRenderEmailTemplateOutput)
        pub fn build(self) -> crate::output::TestRenderEmailTemplateOutput {
            crate::output::TestRenderEmailTemplateOutput {
                rendered_template: self.rendered_template,
            }
        }
    }
}
impl TestRenderEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`TestRenderEmailTemplateOutput`](crate::output::TestRenderEmailTemplateOutput)
    pub fn builder() -> crate::output::test_render_email_template_output::Builder {
        crate::output::test_render_email_template_output::Builder::default()
    }
}

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

/// <p>A unique message ID that you receive when an email is accepted for sending.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendEmailOutput {
    /// <p>A unique identifier for the message that is generated when the message is accepted.</p> <note>
    /// <p>It's possible for Amazon SES to accept a message without sending it. This can happen when the message that you're trying to send has an attachment contains a virus, or when you send a templated email that contains invalid personalization content, for example.</p>
    /// </note>
    pub message_id: std::option::Option<std::string::String>,
}
impl SendEmailOutput {
    /// <p>A unique identifier for the message that is generated when the message is accepted.</p> <note>
    /// <p>It's possible for Amazon SES to accept a message without sending it. This can happen when the message that you're trying to send has an attachment contains a virus, or when you send a templated email that contains invalid personalization content, for example.</p>
    /// </note>
    pub fn message_id(&self) -> std::option::Option<&str> {
        self.message_id.as_deref()
    }
}
impl std::fmt::Debug for SendEmailOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SendEmailOutput");
        formatter.field("message_id", &self.message_id);
        formatter.finish()
    }
}
/// See [`SendEmailOutput`](crate::output::SendEmailOutput)
pub mod send_email_output {
    /// A builder for [`SendEmailOutput`](crate::output::SendEmailOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>A unique identifier for the message that is generated when the message is accepted.</p> <note>
        /// <p>It's possible for Amazon SES to accept a message without sending it. This can happen when the message that you're trying to send has an attachment contains a virus, or when you send a templated email that contains invalid personalization content, for example.</p>
        /// </note>
        pub fn message_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_id = Some(input.into());
            self
        }
        /// <p>A unique identifier for the message that is generated when the message is accepted.</p> <note>
        /// <p>It's possible for Amazon SES to accept a message without sending it. This can happen when the message that you're trying to send has an attachment contains a virus, or when you send a templated email that contains invalid personalization content, for example.</p>
        /// </note>
        pub fn set_message_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_id = input;
            self
        }
        /// Consumes the builder and constructs a [`SendEmailOutput`](crate::output::SendEmailOutput)
        pub fn build(self) -> crate::output::SendEmailOutput {
            crate::output::SendEmailOutput {
                message_id: self.message_id,
            }
        }
    }
}
impl SendEmailOutput {
    /// Creates a new builder-style object to manufacture [`SendEmailOutput`](crate::output::SendEmailOutput)
    pub fn builder() -> crate::output::send_email_output::Builder {
        crate::output::send_email_output::Builder::default()
    }
}

/// <p>The following element is returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendCustomVerificationEmailOutput {
    /// <p>The unique message identifier returned from the <code>SendCustomVerificationEmail</code> operation.</p>
    pub message_id: std::option::Option<std::string::String>,
}
impl SendCustomVerificationEmailOutput {
    /// <p>The unique message identifier returned from the <code>SendCustomVerificationEmail</code> operation.</p>
    pub fn message_id(&self) -> std::option::Option<&str> {
        self.message_id.as_deref()
    }
}
impl std::fmt::Debug for SendCustomVerificationEmailOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SendCustomVerificationEmailOutput");
        formatter.field("message_id", &self.message_id);
        formatter.finish()
    }
}
/// See [`SendCustomVerificationEmailOutput`](crate::output::SendCustomVerificationEmailOutput)
pub mod send_custom_verification_email_output {
    /// A builder for [`SendCustomVerificationEmailOutput`](crate::output::SendCustomVerificationEmailOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) message_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The unique message identifier returned from the <code>SendCustomVerificationEmail</code> operation.</p>
        pub fn message_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.message_id = Some(input.into());
            self
        }
        /// <p>The unique message identifier returned from the <code>SendCustomVerificationEmail</code> operation.</p>
        pub fn set_message_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message_id = input;
            self
        }
        /// Consumes the builder and constructs a [`SendCustomVerificationEmailOutput`](crate::output::SendCustomVerificationEmailOutput)
        pub fn build(self) -> crate::output::SendCustomVerificationEmailOutput {
            crate::output::SendCustomVerificationEmailOutput {
                message_id: self.message_id,
            }
        }
    }
}
impl SendCustomVerificationEmailOutput {
    /// Creates a new builder-style object to manufacture [`SendCustomVerificationEmailOutput`](crate::output::SendCustomVerificationEmailOutput)
    pub fn builder() -> crate::output::send_custom_verification_email_output::Builder {
        crate::output::send_custom_verification_email_output::Builder::default()
    }
}

/// <p>The following data is returned in JSON format by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct SendBulkEmailOutput {
    /// <p>One object per intended recipient. Check each response object and retry any messages with a failure status.</p>
    pub bulk_email_entry_results:
        std::option::Option<std::vec::Vec<crate::model::BulkEmailEntryResult>>,
}
impl SendBulkEmailOutput {
    /// <p>One object per intended recipient. Check each response object and retry any messages with a failure status.</p>
    pub fn bulk_email_entry_results(
        &self,
    ) -> std::option::Option<&[crate::model::BulkEmailEntryResult]> {
        self.bulk_email_entry_results.as_deref()
    }
}
impl std::fmt::Debug for SendBulkEmailOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("SendBulkEmailOutput");
        formatter.field("bulk_email_entry_results", &self.bulk_email_entry_results);
        formatter.finish()
    }
}
/// See [`SendBulkEmailOutput`](crate::output::SendBulkEmailOutput)
pub mod send_bulk_email_output {
    /// A builder for [`SendBulkEmailOutput`](crate::output::SendBulkEmailOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) bulk_email_entry_results:
            std::option::Option<std::vec::Vec<crate::model::BulkEmailEntryResult>>,
    }
    impl Builder {
        /// Appends an item to `bulk_email_entry_results`.
        ///
        /// To override the contents of this collection use [`set_bulk_email_entry_results`](Self::set_bulk_email_entry_results).
        ///
        /// <p>One object per intended recipient. Check each response object and retry any messages with a failure status.</p>
        pub fn bulk_email_entry_results(
            mut self,
            input: crate::model::BulkEmailEntryResult,
        ) -> Self {
            let mut v = self.bulk_email_entry_results.unwrap_or_default();
            v.push(input);
            self.bulk_email_entry_results = Some(v);
            self
        }
        /// <p>One object per intended recipient. Check each response object and retry any messages with a failure status.</p>
        pub fn set_bulk_email_entry_results(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::BulkEmailEntryResult>>,
        ) -> Self {
            self.bulk_email_entry_results = input;
            self
        }
        /// Consumes the builder and constructs a [`SendBulkEmailOutput`](crate::output::SendBulkEmailOutput)
        pub fn build(self) -> crate::output::SendBulkEmailOutput {
            crate::output::SendBulkEmailOutput {
                bulk_email_entry_results: self.bulk_email_entry_results,
            }
        }
    }
}
impl SendBulkEmailOutput {
    /// Creates a new builder-style object to manufacture [`SendBulkEmailOutput`](crate::output::SendBulkEmailOutput)
    pub fn builder() -> crate::output::send_bulk_email_output::Builder {
        crate::output::send_bulk_email_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutSuppressedDestinationOutput {}
impl std::fmt::Debug for PutSuppressedDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutSuppressedDestinationOutput");
        formatter.finish()
    }
}
/// See [`PutSuppressedDestinationOutput`](crate::output::PutSuppressedDestinationOutput)
pub mod put_suppressed_destination_output {
    /// A builder for [`PutSuppressedDestinationOutput`](crate::output::PutSuppressedDestinationOutput)
    #[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 [`PutSuppressedDestinationOutput`](crate::output::PutSuppressedDestinationOutput)
        pub fn build(self) -> crate::output::PutSuppressedDestinationOutput {
            crate::output::PutSuppressedDestinationOutput {}
        }
    }
}
impl PutSuppressedDestinationOutput {
    /// Creates a new builder-style object to manufacture [`PutSuppressedDestinationOutput`](crate::output::PutSuppressedDestinationOutput)
    pub fn builder() -> crate::output::put_suppressed_destination_output::Builder {
        crate::output::put_suppressed_destination_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEmailIdentityMailFromAttributesOutput {}
impl std::fmt::Debug for PutEmailIdentityMailFromAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEmailIdentityMailFromAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutEmailIdentityMailFromAttributesOutput`](crate::output::PutEmailIdentityMailFromAttributesOutput)
pub mod put_email_identity_mail_from_attributes_output {
    /// A builder for [`PutEmailIdentityMailFromAttributesOutput`](crate::output::PutEmailIdentityMailFromAttributesOutput)
    #[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 [`PutEmailIdentityMailFromAttributesOutput`](crate::output::PutEmailIdentityMailFromAttributesOutput)
        pub fn build(self) -> crate::output::PutEmailIdentityMailFromAttributesOutput {
            crate::output::PutEmailIdentityMailFromAttributesOutput {}
        }
    }
}
impl PutEmailIdentityMailFromAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutEmailIdentityMailFromAttributesOutput`](crate::output::PutEmailIdentityMailFromAttributesOutput)
    pub fn builder() -> crate::output::put_email_identity_mail_from_attributes_output::Builder {
        crate::output::put_email_identity_mail_from_attributes_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEmailIdentityFeedbackAttributesOutput {}
impl std::fmt::Debug for PutEmailIdentityFeedbackAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEmailIdentityFeedbackAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutEmailIdentityFeedbackAttributesOutput`](crate::output::PutEmailIdentityFeedbackAttributesOutput)
pub mod put_email_identity_feedback_attributes_output {
    /// A builder for [`PutEmailIdentityFeedbackAttributesOutput`](crate::output::PutEmailIdentityFeedbackAttributesOutput)
    #[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 [`PutEmailIdentityFeedbackAttributesOutput`](crate::output::PutEmailIdentityFeedbackAttributesOutput)
        pub fn build(self) -> crate::output::PutEmailIdentityFeedbackAttributesOutput {
            crate::output::PutEmailIdentityFeedbackAttributesOutput {}
        }
    }
}
impl PutEmailIdentityFeedbackAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutEmailIdentityFeedbackAttributesOutput`](crate::output::PutEmailIdentityFeedbackAttributesOutput)
    pub fn builder() -> crate::output::put_email_identity_feedback_attributes_output::Builder {
        crate::output::put_email_identity_feedback_attributes_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response.</p>
/// <p>The following data is returned in JSON format by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEmailIdentityDkimSigningAttributesOutput {
    /// <p>The DKIM authentication status of the identity. Amazon SES determines the authentication status by searching for specific records in the DNS configuration for your domain. If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to set up DKIM authentication, Amazon SES tries to find three unique CNAME records in the DNS configuration for your domain.</p>
    /// <p>If you provided a public key to perform DKIM authentication, Amazon SES tries to find a TXT record that uses the selector that you specified. The value of the TXT record must be a public key that's paired with the private key that you specified in the process of creating the identity.</p>
    /// <p>The status can be one of the following:</p>
    /// <ul>
    /// <li> <p> <code>PENDING</code> – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.</p> </li>
    /// <li> <p> <code>SUCCESS</code> – The verification process completed successfully.</p> </li>
    /// <li> <p> <code>FAILED</code> – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.</p> </li>
    /// <li> <p> <code>TEMPORARY_FAILURE</code> – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.</p> </li>
    /// <li> <p> <code>NOT_STARTED</code> – The DKIM verification process hasn't been initiated for the domain.</p> </li>
    /// </ul>
    pub dkim_status: std::option::Option<crate::model::DkimStatus>,
    /// <p>If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete.</p>
    /// <p>If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector that's associated with your public key.</p>
    /// <p>Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.</p>
    pub dkim_tokens: std::option::Option<std::vec::Vec<std::string::String>>,
}
impl PutEmailIdentityDkimSigningAttributesOutput {
    /// <p>The DKIM authentication status of the identity. Amazon SES determines the authentication status by searching for specific records in the DNS configuration for your domain. If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to set up DKIM authentication, Amazon SES tries to find three unique CNAME records in the DNS configuration for your domain.</p>
    /// <p>If you provided a public key to perform DKIM authentication, Amazon SES tries to find a TXT record that uses the selector that you specified. The value of the TXT record must be a public key that's paired with the private key that you specified in the process of creating the identity.</p>
    /// <p>The status can be one of the following:</p>
    /// <ul>
    /// <li> <p> <code>PENDING</code> – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.</p> </li>
    /// <li> <p> <code>SUCCESS</code> – The verification process completed successfully.</p> </li>
    /// <li> <p> <code>FAILED</code> – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.</p> </li>
    /// <li> <p> <code>TEMPORARY_FAILURE</code> – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.</p> </li>
    /// <li> <p> <code>NOT_STARTED</code> – The DKIM verification process hasn't been initiated for the domain.</p> </li>
    /// </ul>
    pub fn dkim_status(&self) -> std::option::Option<&crate::model::DkimStatus> {
        self.dkim_status.as_ref()
    }
    /// <p>If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete.</p>
    /// <p>If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector that's associated with your public key.</p>
    /// <p>Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.</p>
    pub fn dkim_tokens(&self) -> std::option::Option<&[std::string::String]> {
        self.dkim_tokens.as_deref()
    }
}
impl std::fmt::Debug for PutEmailIdentityDkimSigningAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEmailIdentityDkimSigningAttributesOutput");
        formatter.field("dkim_status", &self.dkim_status);
        formatter.field("dkim_tokens", &self.dkim_tokens);
        formatter.finish()
    }
}
/// See [`PutEmailIdentityDkimSigningAttributesOutput`](crate::output::PutEmailIdentityDkimSigningAttributesOutput)
pub mod put_email_identity_dkim_signing_attributes_output {
    /// A builder for [`PutEmailIdentityDkimSigningAttributesOutput`](crate::output::PutEmailIdentityDkimSigningAttributesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dkim_status: std::option::Option<crate::model::DkimStatus>,
        pub(crate) dkim_tokens: std::option::Option<std::vec::Vec<std::string::String>>,
    }
    impl Builder {
        /// <p>The DKIM authentication status of the identity. Amazon SES determines the authentication status by searching for specific records in the DNS configuration for your domain. If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to set up DKIM authentication, Amazon SES tries to find three unique CNAME records in the DNS configuration for your domain.</p>
        /// <p>If you provided a public key to perform DKIM authentication, Amazon SES tries to find a TXT record that uses the selector that you specified. The value of the TXT record must be a public key that's paired with the private key that you specified in the process of creating the identity.</p>
        /// <p>The status can be one of the following:</p>
        /// <ul>
        /// <li> <p> <code>PENDING</code> – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.</p> </li>
        /// <li> <p> <code>SUCCESS</code> – The verification process completed successfully.</p> </li>
        /// <li> <p> <code>FAILED</code> – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.</p> </li>
        /// <li> <p> <code>TEMPORARY_FAILURE</code> – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.</p> </li>
        /// <li> <p> <code>NOT_STARTED</code> – The DKIM verification process hasn't been initiated for the domain.</p> </li>
        /// </ul>
        pub fn dkim_status(mut self, input: crate::model::DkimStatus) -> Self {
            self.dkim_status = Some(input);
            self
        }
        /// <p>The DKIM authentication status of the identity. Amazon SES determines the authentication status by searching for specific records in the DNS configuration for your domain. If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to set up DKIM authentication, Amazon SES tries to find three unique CNAME records in the DNS configuration for your domain.</p>
        /// <p>If you provided a public key to perform DKIM authentication, Amazon SES tries to find a TXT record that uses the selector that you specified. The value of the TXT record must be a public key that's paired with the private key that you specified in the process of creating the identity.</p>
        /// <p>The status can be one of the following:</p>
        /// <ul>
        /// <li> <p> <code>PENDING</code> – The verification process was initiated, but Amazon SES hasn't yet detected the DKIM records in the DNS configuration for the domain.</p> </li>
        /// <li> <p> <code>SUCCESS</code> – The verification process completed successfully.</p> </li>
        /// <li> <p> <code>FAILED</code> – The verification process failed. This typically occurs when Amazon SES fails to find the DKIM records in the DNS configuration of the domain.</p> </li>
        /// <li> <p> <code>TEMPORARY_FAILURE</code> – A temporary issue is preventing Amazon SES from determining the DKIM authentication status of the domain.</p> </li>
        /// <li> <p> <code>NOT_STARTED</code> – The DKIM verification process hasn't been initiated for the domain.</p> </li>
        /// </ul>
        pub fn set_dkim_status(
            mut self,
            input: std::option::Option<crate::model::DkimStatus>,
        ) -> Self {
            self.dkim_status = input;
            self
        }
        /// Appends an item to `dkim_tokens`.
        ///
        /// To override the contents of this collection use [`set_dkim_tokens`](Self::set_dkim_tokens).
        ///
        /// <p>If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete.</p>
        /// <p>If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector that's associated with your public key.</p>
        /// <p>Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.</p>
        pub fn dkim_tokens(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.dkim_tokens.unwrap_or_default();
            v.push(input.into());
            self.dkim_tokens = Some(v);
            self
        }
        /// <p>If you used <a href="https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html">Easy DKIM</a> to configure DKIM authentication for the domain, then this object contains a set of unique strings that you use to create a set of CNAME records that you add to the DNS configuration for your domain. When Amazon SES detects these records in the DNS configuration for your domain, the DKIM authentication process is complete.</p>
        /// <p>If you configured DKIM authentication for the domain by providing your own public-private key pair, then this object contains the selector that's associated with your public key.</p>
        /// <p>Regardless of the DKIM authentication method you use, Amazon SES searches for the appropriate records in the DNS configuration of the domain for up to 72 hours.</p>
        pub fn set_dkim_tokens(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.dkim_tokens = input;
            self
        }
        /// Consumes the builder and constructs a [`PutEmailIdentityDkimSigningAttributesOutput`](crate::output::PutEmailIdentityDkimSigningAttributesOutput)
        pub fn build(self) -> crate::output::PutEmailIdentityDkimSigningAttributesOutput {
            crate::output::PutEmailIdentityDkimSigningAttributesOutput {
                dkim_status: self.dkim_status,
                dkim_tokens: self.dkim_tokens,
            }
        }
    }
}
impl PutEmailIdentityDkimSigningAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutEmailIdentityDkimSigningAttributesOutput`](crate::output::PutEmailIdentityDkimSigningAttributesOutput)
    pub fn builder() -> crate::output::put_email_identity_dkim_signing_attributes_output::Builder {
        crate::output::put_email_identity_dkim_signing_attributes_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEmailIdentityDkimAttributesOutput {}
impl std::fmt::Debug for PutEmailIdentityDkimAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEmailIdentityDkimAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutEmailIdentityDkimAttributesOutput`](crate::output::PutEmailIdentityDkimAttributesOutput)
pub mod put_email_identity_dkim_attributes_output {
    /// A builder for [`PutEmailIdentityDkimAttributesOutput`](crate::output::PutEmailIdentityDkimAttributesOutput)
    #[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 [`PutEmailIdentityDkimAttributesOutput`](crate::output::PutEmailIdentityDkimAttributesOutput)
        pub fn build(self) -> crate::output::PutEmailIdentityDkimAttributesOutput {
            crate::output::PutEmailIdentityDkimAttributesOutput {}
        }
    }
}
impl PutEmailIdentityDkimAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutEmailIdentityDkimAttributesOutput`](crate::output::PutEmailIdentityDkimAttributesOutput)
    pub fn builder() -> crate::output::put_email_identity_dkim_attributes_output::Builder {
        crate::output::put_email_identity_dkim_attributes_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutEmailIdentityConfigurationSetAttributesOutput {}
impl std::fmt::Debug for PutEmailIdentityConfigurationSetAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutEmailIdentityConfigurationSetAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutEmailIdentityConfigurationSetAttributesOutput`](crate::output::PutEmailIdentityConfigurationSetAttributesOutput)
pub mod put_email_identity_configuration_set_attributes_output {
    /// A builder for [`PutEmailIdentityConfigurationSetAttributesOutput`](crate::output::PutEmailIdentityConfigurationSetAttributesOutput)
    #[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 [`PutEmailIdentityConfigurationSetAttributesOutput`](crate::output::PutEmailIdentityConfigurationSetAttributesOutput)
        pub fn build(self) -> crate::output::PutEmailIdentityConfigurationSetAttributesOutput {
            crate::output::PutEmailIdentityConfigurationSetAttributesOutput {}
        }
    }
}
impl PutEmailIdentityConfigurationSetAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutEmailIdentityConfigurationSetAttributesOutput`](crate::output::PutEmailIdentityConfigurationSetAttributesOutput)
    pub fn builder(
    ) -> crate::output::put_email_identity_configuration_set_attributes_output::Builder {
        crate::output::put_email_identity_configuration_set_attributes_output::Builder::default()
    }
}

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

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutDedicatedIpWarmupAttributesOutput {}
impl std::fmt::Debug for PutDedicatedIpWarmupAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutDedicatedIpWarmupAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutDedicatedIpWarmupAttributesOutput`](crate::output::PutDedicatedIpWarmupAttributesOutput)
pub mod put_dedicated_ip_warmup_attributes_output {
    /// A builder for [`PutDedicatedIpWarmupAttributesOutput`](crate::output::PutDedicatedIpWarmupAttributesOutput)
    #[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 [`PutDedicatedIpWarmupAttributesOutput`](crate::output::PutDedicatedIpWarmupAttributesOutput)
        pub fn build(self) -> crate::output::PutDedicatedIpWarmupAttributesOutput {
            crate::output::PutDedicatedIpWarmupAttributesOutput {}
        }
    }
}
impl PutDedicatedIpWarmupAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutDedicatedIpWarmupAttributesOutput`](crate::output::PutDedicatedIpWarmupAttributesOutput)
    pub fn builder() -> crate::output::put_dedicated_ip_warmup_attributes_output::Builder {
        crate::output::put_dedicated_ip_warmup_attributes_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutDedicatedIpInPoolOutput {}
impl std::fmt::Debug for PutDedicatedIpInPoolOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutDedicatedIpInPoolOutput");
        formatter.finish()
    }
}
/// See [`PutDedicatedIpInPoolOutput`](crate::output::PutDedicatedIpInPoolOutput)
pub mod put_dedicated_ip_in_pool_output {
    /// A builder for [`PutDedicatedIpInPoolOutput`](crate::output::PutDedicatedIpInPoolOutput)
    #[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 [`PutDedicatedIpInPoolOutput`](crate::output::PutDedicatedIpInPoolOutput)
        pub fn build(self) -> crate::output::PutDedicatedIpInPoolOutput {
            crate::output::PutDedicatedIpInPoolOutput {}
        }
    }
}
impl PutDedicatedIpInPoolOutput {
    /// Creates a new builder-style object to manufacture [`PutDedicatedIpInPoolOutput`](crate::output::PutDedicatedIpInPoolOutput)
    pub fn builder() -> crate::output::put_dedicated_ip_in_pool_output::Builder {
        crate::output::put_dedicated_ip_in_pool_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationSetTrackingOptionsOutput {}
impl std::fmt::Debug for PutConfigurationSetTrackingOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationSetTrackingOptionsOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationSetTrackingOptionsOutput`](crate::output::PutConfigurationSetTrackingOptionsOutput)
pub mod put_configuration_set_tracking_options_output {
    /// A builder for [`PutConfigurationSetTrackingOptionsOutput`](crate::output::PutConfigurationSetTrackingOptionsOutput)
    #[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 [`PutConfigurationSetTrackingOptionsOutput`](crate::output::PutConfigurationSetTrackingOptionsOutput)
        pub fn build(self) -> crate::output::PutConfigurationSetTrackingOptionsOutput {
            crate::output::PutConfigurationSetTrackingOptionsOutput {}
        }
    }
}
impl PutConfigurationSetTrackingOptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationSetTrackingOptionsOutput`](crate::output::PutConfigurationSetTrackingOptionsOutput)
    pub fn builder() -> crate::output::put_configuration_set_tracking_options_output::Builder {
        crate::output::put_configuration_set_tracking_options_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationSetSuppressionOptionsOutput {}
impl std::fmt::Debug for PutConfigurationSetSuppressionOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationSetSuppressionOptionsOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationSetSuppressionOptionsOutput`](crate::output::PutConfigurationSetSuppressionOptionsOutput)
pub mod put_configuration_set_suppression_options_output {
    /// A builder for [`PutConfigurationSetSuppressionOptionsOutput`](crate::output::PutConfigurationSetSuppressionOptionsOutput)
    #[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 [`PutConfigurationSetSuppressionOptionsOutput`](crate::output::PutConfigurationSetSuppressionOptionsOutput)
        pub fn build(self) -> crate::output::PutConfigurationSetSuppressionOptionsOutput {
            crate::output::PutConfigurationSetSuppressionOptionsOutput {}
        }
    }
}
impl PutConfigurationSetSuppressionOptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationSetSuppressionOptionsOutput`](crate::output::PutConfigurationSetSuppressionOptionsOutput)
    pub fn builder() -> crate::output::put_configuration_set_suppression_options_output::Builder {
        crate::output::put_configuration_set_suppression_options_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationSetSendingOptionsOutput {}
impl std::fmt::Debug for PutConfigurationSetSendingOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationSetSendingOptionsOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationSetSendingOptionsOutput`](crate::output::PutConfigurationSetSendingOptionsOutput)
pub mod put_configuration_set_sending_options_output {
    /// A builder for [`PutConfigurationSetSendingOptionsOutput`](crate::output::PutConfigurationSetSendingOptionsOutput)
    #[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 [`PutConfigurationSetSendingOptionsOutput`](crate::output::PutConfigurationSetSendingOptionsOutput)
        pub fn build(self) -> crate::output::PutConfigurationSetSendingOptionsOutput {
            crate::output::PutConfigurationSetSendingOptionsOutput {}
        }
    }
}
impl PutConfigurationSetSendingOptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationSetSendingOptionsOutput`](crate::output::PutConfigurationSetSendingOptionsOutput)
    pub fn builder() -> crate::output::put_configuration_set_sending_options_output::Builder {
        crate::output::put_configuration_set_sending_options_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationSetReputationOptionsOutput {}
impl std::fmt::Debug for PutConfigurationSetReputationOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationSetReputationOptionsOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationSetReputationOptionsOutput`](crate::output::PutConfigurationSetReputationOptionsOutput)
pub mod put_configuration_set_reputation_options_output {
    /// A builder for [`PutConfigurationSetReputationOptionsOutput`](crate::output::PutConfigurationSetReputationOptionsOutput)
    #[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 [`PutConfigurationSetReputationOptionsOutput`](crate::output::PutConfigurationSetReputationOptionsOutput)
        pub fn build(self) -> crate::output::PutConfigurationSetReputationOptionsOutput {
            crate::output::PutConfigurationSetReputationOptionsOutput {}
        }
    }
}
impl PutConfigurationSetReputationOptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationSetReputationOptionsOutput`](crate::output::PutConfigurationSetReputationOptionsOutput)
    pub fn builder() -> crate::output::put_configuration_set_reputation_options_output::Builder {
        crate::output::put_configuration_set_reputation_options_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutConfigurationSetDeliveryOptionsOutput {}
impl std::fmt::Debug for PutConfigurationSetDeliveryOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutConfigurationSetDeliveryOptionsOutput");
        formatter.finish()
    }
}
/// See [`PutConfigurationSetDeliveryOptionsOutput`](crate::output::PutConfigurationSetDeliveryOptionsOutput)
pub mod put_configuration_set_delivery_options_output {
    /// A builder for [`PutConfigurationSetDeliveryOptionsOutput`](crate::output::PutConfigurationSetDeliveryOptionsOutput)
    #[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 [`PutConfigurationSetDeliveryOptionsOutput`](crate::output::PutConfigurationSetDeliveryOptionsOutput)
        pub fn build(self) -> crate::output::PutConfigurationSetDeliveryOptionsOutput {
            crate::output::PutConfigurationSetDeliveryOptionsOutput {}
        }
    }
}
impl PutConfigurationSetDeliveryOptionsOutput {
    /// Creates a new builder-style object to manufacture [`PutConfigurationSetDeliveryOptionsOutput`](crate::output::PutConfigurationSetDeliveryOptionsOutput)
    pub fn builder() -> crate::output::put_configuration_set_delivery_options_output::Builder {
        crate::output::put_configuration_set_delivery_options_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSuppressionAttributesOutput {}
impl std::fmt::Debug for PutAccountSuppressionAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSuppressionAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutAccountSuppressionAttributesOutput`](crate::output::PutAccountSuppressionAttributesOutput)
pub mod put_account_suppression_attributes_output {
    /// A builder for [`PutAccountSuppressionAttributesOutput`](crate::output::PutAccountSuppressionAttributesOutput)
    #[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 [`PutAccountSuppressionAttributesOutput`](crate::output::PutAccountSuppressionAttributesOutput)
        pub fn build(self) -> crate::output::PutAccountSuppressionAttributesOutput {
            crate::output::PutAccountSuppressionAttributesOutput {}
        }
    }
}
impl PutAccountSuppressionAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutAccountSuppressionAttributesOutput`](crate::output::PutAccountSuppressionAttributesOutput)
    pub fn builder() -> crate::output::put_account_suppression_attributes_output::Builder {
        crate::output::put_account_suppression_attributes_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountSendingAttributesOutput {}
impl std::fmt::Debug for PutAccountSendingAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountSendingAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutAccountSendingAttributesOutput`](crate::output::PutAccountSendingAttributesOutput)
pub mod put_account_sending_attributes_output {
    /// A builder for [`PutAccountSendingAttributesOutput`](crate::output::PutAccountSendingAttributesOutput)
    #[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 [`PutAccountSendingAttributesOutput`](crate::output::PutAccountSendingAttributesOutput)
        pub fn build(self) -> crate::output::PutAccountSendingAttributesOutput {
            crate::output::PutAccountSendingAttributesOutput {}
        }
    }
}
impl PutAccountSendingAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutAccountSendingAttributesOutput`](crate::output::PutAccountSendingAttributesOutput)
    pub fn builder() -> crate::output::put_account_sending_attributes_output::Builder {
        crate::output::put_account_sending_attributes_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountDetailsOutput {}
impl std::fmt::Debug for PutAccountDetailsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountDetailsOutput");
        formatter.finish()
    }
}
/// See [`PutAccountDetailsOutput`](crate::output::PutAccountDetailsOutput)
pub mod put_account_details_output {
    /// A builder for [`PutAccountDetailsOutput`](crate::output::PutAccountDetailsOutput)
    #[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 [`PutAccountDetailsOutput`](crate::output::PutAccountDetailsOutput)
        pub fn build(self) -> crate::output::PutAccountDetailsOutput {
            crate::output::PutAccountDetailsOutput {}
        }
    }
}
impl PutAccountDetailsOutput {
    /// Creates a new builder-style object to manufacture [`PutAccountDetailsOutput`](crate::output::PutAccountDetailsOutput)
    pub fn builder() -> crate::output::put_account_details_output::Builder {
        crate::output::put_account_details_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct PutAccountDedicatedIpWarmupAttributesOutput {}
impl std::fmt::Debug for PutAccountDedicatedIpWarmupAttributesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("PutAccountDedicatedIpWarmupAttributesOutput");
        formatter.finish()
    }
}
/// See [`PutAccountDedicatedIpWarmupAttributesOutput`](crate::output::PutAccountDedicatedIpWarmupAttributesOutput)
pub mod put_account_dedicated_ip_warmup_attributes_output {
    /// A builder for [`PutAccountDedicatedIpWarmupAttributesOutput`](crate::output::PutAccountDedicatedIpWarmupAttributesOutput)
    #[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 [`PutAccountDedicatedIpWarmupAttributesOutput`](crate::output::PutAccountDedicatedIpWarmupAttributesOutput)
        pub fn build(self) -> crate::output::PutAccountDedicatedIpWarmupAttributesOutput {
            crate::output::PutAccountDedicatedIpWarmupAttributesOutput {}
        }
    }
}
impl PutAccountDedicatedIpWarmupAttributesOutput {
    /// Creates a new builder-style object to manufacture [`PutAccountDedicatedIpWarmupAttributesOutput`](crate::output::PutAccountDedicatedIpWarmupAttributesOutput)
    pub fn builder() -> crate::output::put_account_dedicated_ip_warmup_attributes_output::Builder {
        crate::output::put_account_dedicated_ip_warmup_attributes_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListTagsForResourceOutput {
    /// <p>An array that lists all the tags that are associated with the resource. Each tag consists of a required tag key (<code>Key</code>) and an associated tag value (<code>Value</code>)</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl ListTagsForResourceOutput {
    /// <p>An array that lists all the tags that are associated with the resource. Each tag consists of a required tag key (<code>Key</code>) and an associated tag value (<code>Value</code>)</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
}
impl std::fmt::Debug for ListTagsForResourceOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListTagsForResourceOutput");
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
pub mod list_tags_for_resource_output {
    /// A builder for [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>An array that lists all the tags that are associated with the resource. Each tag consists of a required tag key (<code>Key</code>) and an associated tag value (<code>Value</code>)</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>An array that lists all the tags that are associated with the resource. Each tag consists of a required tag key (<code>Key</code>) and an associated tag value (<code>Value</code>)</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
        pub fn build(self) -> crate::output::ListTagsForResourceOutput {
            crate::output::ListTagsForResourceOutput { tags: self.tags }
        }
    }
}
impl ListTagsForResourceOutput {
    /// Creates a new builder-style object to manufacture [`ListTagsForResourceOutput`](crate::output::ListTagsForResourceOutput)
    pub fn builder() -> crate::output::list_tags_for_resource_output::Builder {
        crate::output::list_tags_for_resource_output::Builder::default()
    }
}

/// <p>A list of suppressed email addresses.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListSuppressedDestinationsOutput {
    /// <p>A list of summaries, each containing a summary for a suppressed email destination.</p>
    pub suppressed_destination_summaries:
        std::option::Option<std::vec::Vec<crate::model::SuppressedDestinationSummary>>,
    /// <p>A token that indicates that there are additional email addresses on the suppression list for your account. To view additional suppressed addresses, issue another request to <code>ListSuppressedDestinations</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListSuppressedDestinationsOutput {
    /// <p>A list of summaries, each containing a summary for a suppressed email destination.</p>
    pub fn suppressed_destination_summaries(
        &self,
    ) -> std::option::Option<&[crate::model::SuppressedDestinationSummary]> {
        self.suppressed_destination_summaries.as_deref()
    }
    /// <p>A token that indicates that there are additional email addresses on the suppression list for your account. To view additional suppressed addresses, issue another request to <code>ListSuppressedDestinations</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListSuppressedDestinationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListSuppressedDestinationsOutput");
        formatter.field(
            "suppressed_destination_summaries",
            &self.suppressed_destination_summaries,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListSuppressedDestinationsOutput`](crate::output::ListSuppressedDestinationsOutput)
pub mod list_suppressed_destinations_output {
    /// A builder for [`ListSuppressedDestinationsOutput`](crate::output::ListSuppressedDestinationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) suppressed_destination_summaries:
            std::option::Option<std::vec::Vec<crate::model::SuppressedDestinationSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `suppressed_destination_summaries`.
        ///
        /// To override the contents of this collection use [`set_suppressed_destination_summaries`](Self::set_suppressed_destination_summaries).
        ///
        /// <p>A list of summaries, each containing a summary for a suppressed email destination.</p>
        pub fn suppressed_destination_summaries(
            mut self,
            input: crate::model::SuppressedDestinationSummary,
        ) -> Self {
            let mut v = self.suppressed_destination_summaries.unwrap_or_default();
            v.push(input);
            self.suppressed_destination_summaries = Some(v);
            self
        }
        /// <p>A list of summaries, each containing a summary for a suppressed email destination.</p>
        pub fn set_suppressed_destination_summaries(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::SuppressedDestinationSummary>>,
        ) -> Self {
            self.suppressed_destination_summaries = input;
            self
        }
        /// <p>A token that indicates that there are additional email addresses on the suppression list for your account. To view additional suppressed addresses, issue another request to <code>ListSuppressedDestinations</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional email addresses on the suppression list for your account. To view additional suppressed addresses, issue another request to <code>ListSuppressedDestinations</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListSuppressedDestinationsOutput`](crate::output::ListSuppressedDestinationsOutput)
        pub fn build(self) -> crate::output::ListSuppressedDestinationsOutput {
            crate::output::ListSuppressedDestinationsOutput {
                suppressed_destination_summaries: self.suppressed_destination_summaries,
                next_token: self.next_token,
            }
        }
    }
}
impl ListSuppressedDestinationsOutput {
    /// Creates a new builder-style object to manufacture [`ListSuppressedDestinationsOutput`](crate::output::ListSuppressedDestinationsOutput)
    pub fn builder() -> crate::output::list_suppressed_destinations_output::Builder {
        crate::output::list_suppressed_destinations_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListImportJobsOutput {
    /// <p>A list of the import job summaries.</p>
    pub import_jobs: std::option::Option<std::vec::Vec<crate::model::ImportJobSummary>>,
    /// <p>A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to <code>ListImportJobs</code> with the same parameters to retrieve the next page of import jobs.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListImportJobsOutput {
    /// <p>A list of the import job summaries.</p>
    pub fn import_jobs(&self) -> std::option::Option<&[crate::model::ImportJobSummary]> {
        self.import_jobs.as_deref()
    }
    /// <p>A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to <code>ListImportJobs</code> with the same parameters to retrieve the next page of import jobs.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListImportJobsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListImportJobsOutput");
        formatter.field("import_jobs", &self.import_jobs);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListImportJobsOutput`](crate::output::ListImportJobsOutput)
pub mod list_import_jobs_output {
    /// A builder for [`ListImportJobsOutput`](crate::output::ListImportJobsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) import_jobs: std::option::Option<std::vec::Vec<crate::model::ImportJobSummary>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `import_jobs`.
        ///
        /// To override the contents of this collection use [`set_import_jobs`](Self::set_import_jobs).
        ///
        /// <p>A list of the import job summaries.</p>
        pub fn import_jobs(mut self, input: crate::model::ImportJobSummary) -> Self {
            let mut v = self.import_jobs.unwrap_or_default();
            v.push(input);
            self.import_jobs = Some(v);
            self
        }
        /// <p>A list of the import job summaries.</p>
        pub fn set_import_jobs(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ImportJobSummary>>,
        ) -> Self {
            self.import_jobs = input;
            self
        }
        /// <p>A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to <code>ListImportJobs</code> with the same parameters to retrieve the next page of import jobs.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A string token indicating that there might be additional import jobs available to be listed. Copy this token to a subsequent call to <code>ListImportJobs</code> with the same parameters to retrieve the next page of import jobs.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListImportJobsOutput`](crate::output::ListImportJobsOutput)
        pub fn build(self) -> crate::output::ListImportJobsOutput {
            crate::output::ListImportJobsOutput {
                import_jobs: self.import_jobs,
                next_token: self.next_token,
            }
        }
    }
}
impl ListImportJobsOutput {
    /// Creates a new builder-style object to manufacture [`ListImportJobsOutput`](crate::output::ListImportJobsOutput)
    pub fn builder() -> crate::output::list_import_jobs_output::Builder {
        crate::output::list_import_jobs_output::Builder::default()
    }
}

/// <p>The following elements are returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListEmailTemplatesOutput {
    /// <p>An array the contains the name and creation time stamp for each template in your Amazon SES account.</p>
    pub templates_metadata: std::option::Option<std::vec::Vec<crate::model::EmailTemplateMetadata>>,
    /// <p>A token indicating that there are additional email templates available to be listed. Pass this token to a subsequent <code>ListEmailTemplates</code> call to retrieve the next 10 email templates.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListEmailTemplatesOutput {
    /// <p>An array the contains the name and creation time stamp for each template in your Amazon SES account.</p>
    pub fn templates_metadata(
        &self,
    ) -> std::option::Option<&[crate::model::EmailTemplateMetadata]> {
        self.templates_metadata.as_deref()
    }
    /// <p>A token indicating that there are additional email templates available to be listed. Pass this token to a subsequent <code>ListEmailTemplates</code> call to retrieve the next 10 email templates.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListEmailTemplatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListEmailTemplatesOutput");
        formatter.field("templates_metadata", &self.templates_metadata);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListEmailTemplatesOutput`](crate::output::ListEmailTemplatesOutput)
pub mod list_email_templates_output {
    /// A builder for [`ListEmailTemplatesOutput`](crate::output::ListEmailTemplatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) templates_metadata:
            std::option::Option<std::vec::Vec<crate::model::EmailTemplateMetadata>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `templates_metadata`.
        ///
        /// To override the contents of this collection use [`set_templates_metadata`](Self::set_templates_metadata).
        ///
        /// <p>An array the contains the name and creation time stamp for each template in your Amazon SES account.</p>
        pub fn templates_metadata(mut self, input: crate::model::EmailTemplateMetadata) -> Self {
            let mut v = self.templates_metadata.unwrap_or_default();
            v.push(input);
            self.templates_metadata = Some(v);
            self
        }
        /// <p>An array the contains the name and creation time stamp for each template in your Amazon SES account.</p>
        pub fn set_templates_metadata(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EmailTemplateMetadata>>,
        ) -> Self {
            self.templates_metadata = input;
            self
        }
        /// <p>A token indicating that there are additional email templates available to be listed. Pass this token to a subsequent <code>ListEmailTemplates</code> call to retrieve the next 10 email templates.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token indicating that there are additional email templates available to be listed. Pass this token to a subsequent <code>ListEmailTemplates</code> call to retrieve the next 10 email templates.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEmailTemplatesOutput`](crate::output::ListEmailTemplatesOutput)
        pub fn build(self) -> crate::output::ListEmailTemplatesOutput {
            crate::output::ListEmailTemplatesOutput {
                templates_metadata: self.templates_metadata,
                next_token: self.next_token,
            }
        }
    }
}
impl ListEmailTemplatesOutput {
    /// Creates a new builder-style object to manufacture [`ListEmailTemplatesOutput`](crate::output::ListEmailTemplatesOutput)
    pub fn builder() -> crate::output::list_email_templates_output::Builder {
        crate::output::list_email_templates_output::Builder::default()
    }
}

/// <p>A list of all of the identities that you've attempted to verify, regardless of whether or not those identities were successfully verified.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListEmailIdentitiesOutput {
    /// <p>An array that includes all of the email identities associated with your Amazon Web Services account.</p>
    pub email_identities: std::option::Option<std::vec::Vec<crate::model::IdentityInfo>>,
    /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListEmailIdentities</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListEmailIdentitiesOutput {
    /// <p>An array that includes all of the email identities associated with your Amazon Web Services account.</p>
    pub fn email_identities(&self) -> std::option::Option<&[crate::model::IdentityInfo]> {
        self.email_identities.as_deref()
    }
    /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListEmailIdentities</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListEmailIdentitiesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListEmailIdentitiesOutput");
        formatter.field("email_identities", &self.email_identities);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListEmailIdentitiesOutput`](crate::output::ListEmailIdentitiesOutput)
pub mod list_email_identities_output {
    /// A builder for [`ListEmailIdentitiesOutput`](crate::output::ListEmailIdentitiesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) email_identities: std::option::Option<std::vec::Vec<crate::model::IdentityInfo>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `email_identities`.
        ///
        /// To override the contents of this collection use [`set_email_identities`](Self::set_email_identities).
        ///
        /// <p>An array that includes all of the email identities associated with your Amazon Web Services account.</p>
        pub fn email_identities(mut self, input: crate::model::IdentityInfo) -> Self {
            let mut v = self.email_identities.unwrap_or_default();
            v.push(input);
            self.email_identities = Some(v);
            self
        }
        /// <p>An array that includes all of the email identities associated with your Amazon Web Services account.</p>
        pub fn set_email_identities(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::IdentityInfo>>,
        ) -> Self {
            self.email_identities = input;
            self
        }
        /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListEmailIdentities</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListEmailIdentities</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListEmailIdentitiesOutput`](crate::output::ListEmailIdentitiesOutput)
        pub fn build(self) -> crate::output::ListEmailIdentitiesOutput {
            crate::output::ListEmailIdentitiesOutput {
                email_identities: self.email_identities,
                next_token: self.next_token,
            }
        }
    }
}
impl ListEmailIdentitiesOutput {
    /// Creates a new builder-style object to manufacture [`ListEmailIdentitiesOutput`](crate::output::ListEmailIdentitiesOutput)
    pub fn builder() -> crate::output::list_email_identities_output::Builder {
        crate::output::list_email_identities_output::Builder::default()
    }
}

/// <p>An array of objects that provide deliverability data for all the campaigns that used a specific domain to send email during a specified time range. This data is available for a domain only if you enabled the Deliverability dashboard for the domain.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDomainDeliverabilityCampaignsOutput {
    /// <p>An array of responses, one for each campaign that used the domain to send email during the specified time range.</p>
    pub domain_deliverability_campaigns:
        std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityCampaign>>,
    /// <p>A token that’s returned from a previous call to the <code>ListDomainDeliverabilityCampaigns</code> operation. This token indicates the position of the campaign in the list of campaigns.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDomainDeliverabilityCampaignsOutput {
    /// <p>An array of responses, one for each campaign that used the domain to send email during the specified time range.</p>
    pub fn domain_deliverability_campaigns(
        &self,
    ) -> std::option::Option<&[crate::model::DomainDeliverabilityCampaign]> {
        self.domain_deliverability_campaigns.as_deref()
    }
    /// <p>A token that’s returned from a previous call to the <code>ListDomainDeliverabilityCampaigns</code> operation. This token indicates the position of the campaign in the list of campaigns.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDomainDeliverabilityCampaignsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDomainDeliverabilityCampaignsOutput");
        formatter.field(
            "domain_deliverability_campaigns",
            &self.domain_deliverability_campaigns,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDomainDeliverabilityCampaignsOutput`](crate::output::ListDomainDeliverabilityCampaignsOutput)
pub mod list_domain_deliverability_campaigns_output {
    /// A builder for [`ListDomainDeliverabilityCampaignsOutput`](crate::output::ListDomainDeliverabilityCampaignsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_deliverability_campaigns:
            std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityCampaign>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `domain_deliverability_campaigns`.
        ///
        /// To override the contents of this collection use [`set_domain_deliverability_campaigns`](Self::set_domain_deliverability_campaigns).
        ///
        /// <p>An array of responses, one for each campaign that used the domain to send email during the specified time range.</p>
        pub fn domain_deliverability_campaigns(
            mut self,
            input: crate::model::DomainDeliverabilityCampaign,
        ) -> Self {
            let mut v = self.domain_deliverability_campaigns.unwrap_or_default();
            v.push(input);
            self.domain_deliverability_campaigns = Some(v);
            self
        }
        /// <p>An array of responses, one for each campaign that used the domain to send email during the specified time range.</p>
        pub fn set_domain_deliverability_campaigns(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityCampaign>>,
        ) -> Self {
            self.domain_deliverability_campaigns = input;
            self
        }
        /// <p>A token that’s returned from a previous call to the <code>ListDomainDeliverabilityCampaigns</code> operation. This token indicates the position of the campaign in the list of campaigns.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that’s returned from a previous call to the <code>ListDomainDeliverabilityCampaigns</code> operation. This token indicates the position of the campaign in the list of campaigns.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDomainDeliverabilityCampaignsOutput`](crate::output::ListDomainDeliverabilityCampaignsOutput)
        pub fn build(self) -> crate::output::ListDomainDeliverabilityCampaignsOutput {
            crate::output::ListDomainDeliverabilityCampaignsOutput {
                domain_deliverability_campaigns: self.domain_deliverability_campaigns,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDomainDeliverabilityCampaignsOutput {
    /// Creates a new builder-style object to manufacture [`ListDomainDeliverabilityCampaignsOutput`](crate::output::ListDomainDeliverabilityCampaignsOutput)
    pub fn builder() -> crate::output::list_domain_deliverability_campaigns_output::Builder {
        crate::output::list_domain_deliverability_campaigns_output::Builder::default()
    }
}

/// <p>A list of the predictive inbox placement test reports that are available for your account, regardless of whether or not those tests are complete.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDeliverabilityTestReportsOutput {
    /// <p>An object that contains a lists of predictive inbox placement tests that you've performed.</p>
    pub deliverability_test_reports:
        std::option::Option<std::vec::Vec<crate::model::DeliverabilityTestReport>>,
    /// <p>A token that indicates that there are additional predictive inbox placement tests to list. To view additional predictive inbox placement tests, issue another request to <code>ListDeliverabilityTestReports</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDeliverabilityTestReportsOutput {
    /// <p>An object that contains a lists of predictive inbox placement tests that you've performed.</p>
    pub fn deliverability_test_reports(
        &self,
    ) -> std::option::Option<&[crate::model::DeliverabilityTestReport]> {
        self.deliverability_test_reports.as_deref()
    }
    /// <p>A token that indicates that there are additional predictive inbox placement tests to list. To view additional predictive inbox placement tests, issue another request to <code>ListDeliverabilityTestReports</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDeliverabilityTestReportsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDeliverabilityTestReportsOutput");
        formatter.field(
            "deliverability_test_reports",
            &self.deliverability_test_reports,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDeliverabilityTestReportsOutput`](crate::output::ListDeliverabilityTestReportsOutput)
pub mod list_deliverability_test_reports_output {
    /// A builder for [`ListDeliverabilityTestReportsOutput`](crate::output::ListDeliverabilityTestReportsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deliverability_test_reports:
            std::option::Option<std::vec::Vec<crate::model::DeliverabilityTestReport>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `deliverability_test_reports`.
        ///
        /// To override the contents of this collection use [`set_deliverability_test_reports`](Self::set_deliverability_test_reports).
        ///
        /// <p>An object that contains a lists of predictive inbox placement tests that you've performed.</p>
        pub fn deliverability_test_reports(
            mut self,
            input: crate::model::DeliverabilityTestReport,
        ) -> Self {
            let mut v = self.deliverability_test_reports.unwrap_or_default();
            v.push(input);
            self.deliverability_test_reports = Some(v);
            self
        }
        /// <p>An object that contains a lists of predictive inbox placement tests that you've performed.</p>
        pub fn set_deliverability_test_reports(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DeliverabilityTestReport>>,
        ) -> Self {
            self.deliverability_test_reports = input;
            self
        }
        /// <p>A token that indicates that there are additional predictive inbox placement tests to list. To view additional predictive inbox placement tests, issue another request to <code>ListDeliverabilityTestReports</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional predictive inbox placement tests to list. To view additional predictive inbox placement tests, issue another request to <code>ListDeliverabilityTestReports</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDeliverabilityTestReportsOutput`](crate::output::ListDeliverabilityTestReportsOutput)
        pub fn build(self) -> crate::output::ListDeliverabilityTestReportsOutput {
            crate::output::ListDeliverabilityTestReportsOutput {
                deliverability_test_reports: self.deliverability_test_reports,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDeliverabilityTestReportsOutput {
    /// Creates a new builder-style object to manufacture [`ListDeliverabilityTestReportsOutput`](crate::output::ListDeliverabilityTestReportsOutput)
    pub fn builder() -> crate::output::list_deliverability_test_reports_output::Builder {
        crate::output::list_deliverability_test_reports_output::Builder::default()
    }
}

/// <p>A list of dedicated IP pools.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListDedicatedIpPoolsOutput {
    /// <p>A list of all of the dedicated IP pools that are associated with your Amazon Web Services account in the current Region.</p>
    pub dedicated_ip_pools: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>A token that indicates that there are additional IP pools to list. To view additional IP pools, issue another request to <code>ListDedicatedIpPools</code>, passing this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListDedicatedIpPoolsOutput {
    /// <p>A list of all of the dedicated IP pools that are associated with your Amazon Web Services account in the current Region.</p>
    pub fn dedicated_ip_pools(&self) -> std::option::Option<&[std::string::String]> {
        self.dedicated_ip_pools.as_deref()
    }
    /// <p>A token that indicates that there are additional IP pools to list. To view additional IP pools, issue another request to <code>ListDedicatedIpPools</code>, passing this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListDedicatedIpPoolsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListDedicatedIpPoolsOutput");
        formatter.field("dedicated_ip_pools", &self.dedicated_ip_pools);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListDedicatedIpPoolsOutput`](crate::output::ListDedicatedIpPoolsOutput)
pub mod list_dedicated_ip_pools_output {
    /// A builder for [`ListDedicatedIpPoolsOutput`](crate::output::ListDedicatedIpPoolsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dedicated_ip_pools: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `dedicated_ip_pools`.
        ///
        /// To override the contents of this collection use [`set_dedicated_ip_pools`](Self::set_dedicated_ip_pools).
        ///
        /// <p>A list of all of the dedicated IP pools that are associated with your Amazon Web Services account in the current Region.</p>
        pub fn dedicated_ip_pools(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.dedicated_ip_pools.unwrap_or_default();
            v.push(input.into());
            self.dedicated_ip_pools = Some(v);
            self
        }
        /// <p>A list of all of the dedicated IP pools that are associated with your Amazon Web Services account in the current Region.</p>
        pub fn set_dedicated_ip_pools(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.dedicated_ip_pools = input;
            self
        }
        /// <p>A token that indicates that there are additional IP pools to list. To view additional IP pools, issue another request to <code>ListDedicatedIpPools</code>, passing this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional IP pools to list. To view additional IP pools, issue another request to <code>ListDedicatedIpPools</code>, passing this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListDedicatedIpPoolsOutput`](crate::output::ListDedicatedIpPoolsOutput)
        pub fn build(self) -> crate::output::ListDedicatedIpPoolsOutput {
            crate::output::ListDedicatedIpPoolsOutput {
                dedicated_ip_pools: self.dedicated_ip_pools,
                next_token: self.next_token,
            }
        }
    }
}
impl ListDedicatedIpPoolsOutput {
    /// Creates a new builder-style object to manufacture [`ListDedicatedIpPoolsOutput`](crate::output::ListDedicatedIpPoolsOutput)
    pub fn builder() -> crate::output::list_dedicated_ip_pools_output::Builder {
        crate::output::list_dedicated_ip_pools_output::Builder::default()
    }
}

/// <p>The following elements are returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListCustomVerificationEmailTemplatesOutput {
    /// <p>A list of the custom verification email templates that exist in your account.</p>
    pub custom_verification_email_templates:
        std::option::Option<std::vec::Vec<crate::model::CustomVerificationEmailTemplateMetadata>>,
    /// <p>A token indicating that there are additional custom verification email templates available to be listed. Pass this token to a subsequent call to <code>ListCustomVerificationEmailTemplates</code> to retrieve the next 50 custom verification email templates.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListCustomVerificationEmailTemplatesOutput {
    /// <p>A list of the custom verification email templates that exist in your account.</p>
    pub fn custom_verification_email_templates(
        &self,
    ) -> std::option::Option<&[crate::model::CustomVerificationEmailTemplateMetadata]> {
        self.custom_verification_email_templates.as_deref()
    }
    /// <p>A token indicating that there are additional custom verification email templates available to be listed. Pass this token to a subsequent call to <code>ListCustomVerificationEmailTemplates</code> to retrieve the next 50 custom verification email templates.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListCustomVerificationEmailTemplatesOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListCustomVerificationEmailTemplatesOutput");
        formatter.field(
            "custom_verification_email_templates",
            &self.custom_verification_email_templates,
        );
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListCustomVerificationEmailTemplatesOutput`](crate::output::ListCustomVerificationEmailTemplatesOutput)
pub mod list_custom_verification_email_templates_output {
    /// A builder for [`ListCustomVerificationEmailTemplatesOutput`](crate::output::ListCustomVerificationEmailTemplatesOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) custom_verification_email_templates: std::option::Option<
            std::vec::Vec<crate::model::CustomVerificationEmailTemplateMetadata>,
        >,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `custom_verification_email_templates`.
        ///
        /// To override the contents of this collection use [`set_custom_verification_email_templates`](Self::set_custom_verification_email_templates).
        ///
        /// <p>A list of the custom verification email templates that exist in your account.</p>
        pub fn custom_verification_email_templates(
            mut self,
            input: crate::model::CustomVerificationEmailTemplateMetadata,
        ) -> Self {
            let mut v = self.custom_verification_email_templates.unwrap_or_default();
            v.push(input);
            self.custom_verification_email_templates = Some(v);
            self
        }
        /// <p>A list of the custom verification email templates that exist in your account.</p>
        pub fn set_custom_verification_email_templates(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::CustomVerificationEmailTemplateMetadata>,
            >,
        ) -> Self {
            self.custom_verification_email_templates = input;
            self
        }
        /// <p>A token indicating that there are additional custom verification email templates available to be listed. Pass this token to a subsequent call to <code>ListCustomVerificationEmailTemplates</code> to retrieve the next 50 custom verification email templates.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token indicating that there are additional custom verification email templates available to be listed. Pass this token to a subsequent call to <code>ListCustomVerificationEmailTemplates</code> to retrieve the next 50 custom verification email templates.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListCustomVerificationEmailTemplatesOutput`](crate::output::ListCustomVerificationEmailTemplatesOutput)
        pub fn build(self) -> crate::output::ListCustomVerificationEmailTemplatesOutput {
            crate::output::ListCustomVerificationEmailTemplatesOutput {
                custom_verification_email_templates: self.custom_verification_email_templates,
                next_token: self.next_token,
            }
        }
    }
}
impl ListCustomVerificationEmailTemplatesOutput {
    /// Creates a new builder-style object to manufacture [`ListCustomVerificationEmailTemplatesOutput`](crate::output::ListCustomVerificationEmailTemplatesOutput)
    pub fn builder() -> crate::output::list_custom_verification_email_templates_output::Builder {
        crate::output::list_custom_verification_email_templates_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListContactsOutput {
    /// <p>The contacts present in a specific contact list.</p>
    pub contacts: std::option::Option<std::vec::Vec<crate::model::Contact>>,
    /// <p>A string token indicating that there might be additional contacts available to be listed. Copy this token to a subsequent call to <code>ListContacts</code> with the same parameters to retrieve the next page of contacts.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListContactsOutput {
    /// <p>The contacts present in a specific contact list.</p>
    pub fn contacts(&self) -> std::option::Option<&[crate::model::Contact]> {
        self.contacts.as_deref()
    }
    /// <p>A string token indicating that there might be additional contacts available to be listed. Copy this token to a subsequent call to <code>ListContacts</code> with the same parameters to retrieve the next page of contacts.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListContactsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListContactsOutput");
        formatter.field("contacts", &self.contacts);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListContactsOutput`](crate::output::ListContactsOutput)
pub mod list_contacts_output {
    /// A builder for [`ListContactsOutput`](crate::output::ListContactsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) contacts: std::option::Option<std::vec::Vec<crate::model::Contact>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `contacts`.
        ///
        /// To override the contents of this collection use [`set_contacts`](Self::set_contacts).
        ///
        /// <p>The contacts present in a specific contact list.</p>
        pub fn contacts(mut self, input: crate::model::Contact) -> Self {
            let mut v = self.contacts.unwrap_or_default();
            v.push(input);
            self.contacts = Some(v);
            self
        }
        /// <p>The contacts present in a specific contact list.</p>
        pub fn set_contacts(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Contact>>,
        ) -> Self {
            self.contacts = input;
            self
        }
        /// <p>A string token indicating that there might be additional contacts available to be listed. Copy this token to a subsequent call to <code>ListContacts</code> with the same parameters to retrieve the next page of contacts.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A string token indicating that there might be additional contacts available to be listed. Copy this token to a subsequent call to <code>ListContacts</code> with the same parameters to retrieve the next page of contacts.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListContactsOutput`](crate::output::ListContactsOutput)
        pub fn build(self) -> crate::output::ListContactsOutput {
            crate::output::ListContactsOutput {
                contacts: self.contacts,
                next_token: self.next_token,
            }
        }
    }
}
impl ListContactsOutput {
    /// Creates a new builder-style object to manufacture [`ListContactsOutput`](crate::output::ListContactsOutput)
    pub fn builder() -> crate::output::list_contacts_output::Builder {
        crate::output::list_contacts_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListContactListsOutput {
    /// <p>The available contact lists.</p>
    pub contact_lists: std::option::Option<std::vec::Vec<crate::model::ContactList>>,
    /// <p>A string token indicating that there might be additional contact lists available to be listed. Copy this token to a subsequent call to <code>ListContactLists</code> with the same parameters to retrieve the next page of contact lists.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListContactListsOutput {
    /// <p>The available contact lists.</p>
    pub fn contact_lists(&self) -> std::option::Option<&[crate::model::ContactList]> {
        self.contact_lists.as_deref()
    }
    /// <p>A string token indicating that there might be additional contact lists available to be listed. Copy this token to a subsequent call to <code>ListContactLists</code> with the same parameters to retrieve the next page of contact lists.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListContactListsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListContactListsOutput");
        formatter.field("contact_lists", &self.contact_lists);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListContactListsOutput`](crate::output::ListContactListsOutput)
pub mod list_contact_lists_output {
    /// A builder for [`ListContactListsOutput`](crate::output::ListContactListsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) contact_lists: std::option::Option<std::vec::Vec<crate::model::ContactList>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `contact_lists`.
        ///
        /// To override the contents of this collection use [`set_contact_lists`](Self::set_contact_lists).
        ///
        /// <p>The available contact lists.</p>
        pub fn contact_lists(mut self, input: crate::model::ContactList) -> Self {
            let mut v = self.contact_lists.unwrap_or_default();
            v.push(input);
            self.contact_lists = Some(v);
            self
        }
        /// <p>The available contact lists.</p>
        pub fn set_contact_lists(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::ContactList>>,
        ) -> Self {
            self.contact_lists = input;
            self
        }
        /// <p>A string token indicating that there might be additional contact lists available to be listed. Copy this token to a subsequent call to <code>ListContactLists</code> with the same parameters to retrieve the next page of contact lists.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A string token indicating that there might be additional contact lists available to be listed. Copy this token to a subsequent call to <code>ListContactLists</code> with the same parameters to retrieve the next page of contact lists.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListContactListsOutput`](crate::output::ListContactListsOutput)
        pub fn build(self) -> crate::output::ListContactListsOutput {
            crate::output::ListContactListsOutput {
                contact_lists: self.contact_lists,
                next_token: self.next_token,
            }
        }
    }
}
impl ListContactListsOutput {
    /// Creates a new builder-style object to manufacture [`ListContactListsOutput`](crate::output::ListContactListsOutput)
    pub fn builder() -> crate::output::list_contact_lists_output::Builder {
        crate::output::list_contact_lists_output::Builder::default()
    }
}

/// <p>A list of configuration sets in your Amazon SES account in the current Amazon Web Services Region.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct ListConfigurationSetsOutput {
    /// <p>An array that contains all of the configuration sets in your Amazon SES account in the current Amazon Web Services Region.</p>
    pub configuration_sets: std::option::Option<std::vec::Vec<std::string::String>>,
    /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListConfigurationSets</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl ListConfigurationSetsOutput {
    /// <p>An array that contains all of the configuration sets in your Amazon SES account in the current Amazon Web Services Region.</p>
    pub fn configuration_sets(&self) -> std::option::Option<&[std::string::String]> {
        self.configuration_sets.as_deref()
    }
    /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListConfigurationSets</code>, and pass this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for ListConfigurationSetsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("ListConfigurationSetsOutput");
        formatter.field("configuration_sets", &self.configuration_sets);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`ListConfigurationSetsOutput`](crate::output::ListConfigurationSetsOutput)
pub mod list_configuration_sets_output {
    /// A builder for [`ListConfigurationSetsOutput`](crate::output::ListConfigurationSetsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_sets: std::option::Option<std::vec::Vec<std::string::String>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `configuration_sets`.
        ///
        /// To override the contents of this collection use [`set_configuration_sets`](Self::set_configuration_sets).
        ///
        /// <p>An array that contains all of the configuration sets in your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn configuration_sets(mut self, input: impl Into<std::string::String>) -> Self {
            let mut v = self.configuration_sets.unwrap_or_default();
            v.push(input.into());
            self.configuration_sets = Some(v);
            self
        }
        /// <p>An array that contains all of the configuration sets in your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn set_configuration_sets(
            mut self,
            input: std::option::Option<std::vec::Vec<std::string::String>>,
        ) -> Self {
            self.configuration_sets = input;
            self
        }
        /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListConfigurationSets</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional configuration sets to list. To view additional configuration sets, issue another request to <code>ListConfigurationSets</code>, and pass this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`ListConfigurationSetsOutput`](crate::output::ListConfigurationSetsOutput)
        pub fn build(self) -> crate::output::ListConfigurationSetsOutput {
            crate::output::ListConfigurationSetsOutput {
                configuration_sets: self.configuration_sets,
                next_token: self.next_token,
            }
        }
    }
}
impl ListConfigurationSetsOutput {
    /// Creates a new builder-style object to manufacture [`ListConfigurationSetsOutput`](crate::output::ListConfigurationSetsOutput)
    pub fn builder() -> crate::output::list_configuration_sets_output::Builder {
        crate::output::list_configuration_sets_output::Builder::default()
    }
}

/// <p>Information about the suppressed email address.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetSuppressedDestinationOutput {
    /// <p>An object containing information about the suppressed email address.</p>
    pub suppressed_destination: std::option::Option<crate::model::SuppressedDestination>,
}
impl GetSuppressedDestinationOutput {
    /// <p>An object containing information about the suppressed email address.</p>
    pub fn suppressed_destination(
        &self,
    ) -> std::option::Option<&crate::model::SuppressedDestination> {
        self.suppressed_destination.as_ref()
    }
}
impl std::fmt::Debug for GetSuppressedDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetSuppressedDestinationOutput");
        formatter.field("suppressed_destination", &self.suppressed_destination);
        formatter.finish()
    }
}
/// See [`GetSuppressedDestinationOutput`](crate::output::GetSuppressedDestinationOutput)
pub mod get_suppressed_destination_output {
    /// A builder for [`GetSuppressedDestinationOutput`](crate::output::GetSuppressedDestinationOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) suppressed_destination: std::option::Option<crate::model::SuppressedDestination>,
    }
    impl Builder {
        /// <p>An object containing information about the suppressed email address.</p>
        pub fn suppressed_destination(
            mut self,
            input: crate::model::SuppressedDestination,
        ) -> Self {
            self.suppressed_destination = Some(input);
            self
        }
        /// <p>An object containing information about the suppressed email address.</p>
        pub fn set_suppressed_destination(
            mut self,
            input: std::option::Option<crate::model::SuppressedDestination>,
        ) -> Self {
            self.suppressed_destination = input;
            self
        }
        /// Consumes the builder and constructs a [`GetSuppressedDestinationOutput`](crate::output::GetSuppressedDestinationOutput)
        pub fn build(self) -> crate::output::GetSuppressedDestinationOutput {
            crate::output::GetSuppressedDestinationOutput {
                suppressed_destination: self.suppressed_destination,
            }
        }
    }
}
impl GetSuppressedDestinationOutput {
    /// Creates a new builder-style object to manufacture [`GetSuppressedDestinationOutput`](crate::output::GetSuppressedDestinationOutput)
    pub fn builder() -> crate::output::get_suppressed_destination_output::Builder {
        crate::output::get_suppressed_destination_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetImportJobOutput {
    /// <p>A string that represents the import job ID.</p>
    pub job_id: std::option::Option<std::string::String>,
    /// <p>The destination of the import job.</p>
    pub import_destination: std::option::Option<crate::model::ImportDestination>,
    /// <p>The data source of the import job.</p>
    pub import_data_source: std::option::Option<crate::model::ImportDataSource>,
    /// <p>The failure details about an import job.</p>
    pub failure_info: std::option::Option<crate::model::FailureInfo>,
    /// <p>The status of the import job.</p>
    pub job_status: std::option::Option<crate::model::JobStatus>,
    /// <p>The time stamp of when the import job was created.</p>
    pub created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The time stamp of when the import job was completed.</p>
    pub completed_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The current number of records processed.</p>
    pub processed_records_count: std::option::Option<i32>,
    /// <p>The number of records that failed processing because of invalid input or other reasons.</p>
    pub failed_records_count: std::option::Option<i32>,
}
impl GetImportJobOutput {
    /// <p>A string that represents the import job ID.</p>
    pub fn job_id(&self) -> std::option::Option<&str> {
        self.job_id.as_deref()
    }
    /// <p>The destination of the import job.</p>
    pub fn import_destination(&self) -> std::option::Option<&crate::model::ImportDestination> {
        self.import_destination.as_ref()
    }
    /// <p>The data source of the import job.</p>
    pub fn import_data_source(&self) -> std::option::Option<&crate::model::ImportDataSource> {
        self.import_data_source.as_ref()
    }
    /// <p>The failure details about an import job.</p>
    pub fn failure_info(&self) -> std::option::Option<&crate::model::FailureInfo> {
        self.failure_info.as_ref()
    }
    /// <p>The status of the import job.</p>
    pub fn job_status(&self) -> std::option::Option<&crate::model::JobStatus> {
        self.job_status.as_ref()
    }
    /// <p>The time stamp of when the import job was created.</p>
    pub fn created_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_timestamp.as_ref()
    }
    /// <p>The time stamp of when the import job was completed.</p>
    pub fn completed_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.completed_timestamp.as_ref()
    }
    /// <p>The current number of records processed.</p>
    pub fn processed_records_count(&self) -> std::option::Option<i32> {
        self.processed_records_count
    }
    /// <p>The number of records that failed processing because of invalid input or other reasons.</p>
    pub fn failed_records_count(&self) -> std::option::Option<i32> {
        self.failed_records_count
    }
}
impl std::fmt::Debug for GetImportJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetImportJobOutput");
        formatter.field("job_id", &self.job_id);
        formatter.field("import_destination", &self.import_destination);
        formatter.field("import_data_source", &self.import_data_source);
        formatter.field("failure_info", &self.failure_info);
        formatter.field("job_status", &self.job_status);
        formatter.field("created_timestamp", &self.created_timestamp);
        formatter.field("completed_timestamp", &self.completed_timestamp);
        formatter.field("processed_records_count", &self.processed_records_count);
        formatter.field("failed_records_count", &self.failed_records_count);
        formatter.finish()
    }
}
/// See [`GetImportJobOutput`](crate::output::GetImportJobOutput)
pub mod get_import_job_output {
    /// A builder for [`GetImportJobOutput`](crate::output::GetImportJobOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_id: std::option::Option<std::string::String>,
        pub(crate) import_destination: std::option::Option<crate::model::ImportDestination>,
        pub(crate) import_data_source: std::option::Option<crate::model::ImportDataSource>,
        pub(crate) failure_info: std::option::Option<crate::model::FailureInfo>,
        pub(crate) job_status: std::option::Option<crate::model::JobStatus>,
        pub(crate) created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) completed_timestamp: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) processed_records_count: std::option::Option<i32>,
        pub(crate) failed_records_count: std::option::Option<i32>,
    }
    impl Builder {
        /// <p>A string that represents the import job ID.</p>
        pub fn job_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.job_id = Some(input.into());
            self
        }
        /// <p>A string that represents the import job ID.</p>
        pub fn set_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.job_id = input;
            self
        }
        /// <p>The destination of the import job.</p>
        pub fn import_destination(mut self, input: crate::model::ImportDestination) -> Self {
            self.import_destination = Some(input);
            self
        }
        /// <p>The destination of the import job.</p>
        pub fn set_import_destination(
            mut self,
            input: std::option::Option<crate::model::ImportDestination>,
        ) -> Self {
            self.import_destination = input;
            self
        }
        /// <p>The data source of the import job.</p>
        pub fn import_data_source(mut self, input: crate::model::ImportDataSource) -> Self {
            self.import_data_source = Some(input);
            self
        }
        /// <p>The data source of the import job.</p>
        pub fn set_import_data_source(
            mut self,
            input: std::option::Option<crate::model::ImportDataSource>,
        ) -> Self {
            self.import_data_source = input;
            self
        }
        /// <p>The failure details about an import job.</p>
        pub fn failure_info(mut self, input: crate::model::FailureInfo) -> Self {
            self.failure_info = Some(input);
            self
        }
        /// <p>The failure details about an import job.</p>
        pub fn set_failure_info(
            mut self,
            input: std::option::Option<crate::model::FailureInfo>,
        ) -> Self {
            self.failure_info = input;
            self
        }
        /// <p>The status of the import job.</p>
        pub fn job_status(mut self, input: crate::model::JobStatus) -> Self {
            self.job_status = Some(input);
            self
        }
        /// <p>The status of the import job.</p>
        pub fn set_job_status(
            mut self,
            input: std::option::Option<crate::model::JobStatus>,
        ) -> Self {
            self.job_status = input;
            self
        }
        /// <p>The time stamp of when the import job was created.</p>
        pub fn created_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_timestamp = Some(input);
            self
        }
        /// <p>The time stamp of when the import job was created.</p>
        pub fn set_created_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_timestamp = input;
            self
        }
        /// <p>The time stamp of when the import job was completed.</p>
        pub fn completed_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.completed_timestamp = Some(input);
            self
        }
        /// <p>The time stamp of when the import job was completed.</p>
        pub fn set_completed_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.completed_timestamp = input;
            self
        }
        /// <p>The current number of records processed.</p>
        pub fn processed_records_count(mut self, input: i32) -> Self {
            self.processed_records_count = Some(input);
            self
        }
        /// <p>The current number of records processed.</p>
        pub fn set_processed_records_count(mut self, input: std::option::Option<i32>) -> Self {
            self.processed_records_count = input;
            self
        }
        /// <p>The number of records that failed processing because of invalid input or other reasons.</p>
        pub fn failed_records_count(mut self, input: i32) -> Self {
            self.failed_records_count = Some(input);
            self
        }
        /// <p>The number of records that failed processing because of invalid input or other reasons.</p>
        pub fn set_failed_records_count(mut self, input: std::option::Option<i32>) -> Self {
            self.failed_records_count = input;
            self
        }
        /// Consumes the builder and constructs a [`GetImportJobOutput`](crate::output::GetImportJobOutput)
        pub fn build(self) -> crate::output::GetImportJobOutput {
            crate::output::GetImportJobOutput {
                job_id: self.job_id,
                import_destination: self.import_destination,
                import_data_source: self.import_data_source,
                failure_info: self.failure_info,
                job_status: self.job_status,
                created_timestamp: self.created_timestamp,
                completed_timestamp: self.completed_timestamp,
                processed_records_count: self.processed_records_count,
                failed_records_count: self.failed_records_count,
            }
        }
    }
}
impl GetImportJobOutput {
    /// Creates a new builder-style object to manufacture [`GetImportJobOutput`](crate::output::GetImportJobOutput)
    pub fn builder() -> crate::output::get_import_job_output::Builder {
        crate::output::get_import_job_output::Builder::default()
    }
}

/// <p>The following element is returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetEmailTemplateOutput {
    /// <p>The name of the template.</p>
    pub template_name: std::option::Option<std::string::String>,
    /// <p>The content of the email template, composed of a subject line, an HTML part, and a text-only part.</p>
    pub template_content: std::option::Option<crate::model::EmailTemplateContent>,
}
impl GetEmailTemplateOutput {
    /// <p>The name of the template.</p>
    pub fn template_name(&self) -> std::option::Option<&str> {
        self.template_name.as_deref()
    }
    /// <p>The content of the email template, composed of a subject line, an HTML part, and a text-only part.</p>
    pub fn template_content(&self) -> std::option::Option<&crate::model::EmailTemplateContent> {
        self.template_content.as_ref()
    }
}
impl std::fmt::Debug for GetEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetEmailTemplateOutput");
        formatter.field("template_name", &self.template_name);
        formatter.field("template_content", &self.template_content);
        formatter.finish()
    }
}
/// See [`GetEmailTemplateOutput`](crate::output::GetEmailTemplateOutput)
pub mod get_email_template_output {
    /// A builder for [`GetEmailTemplateOutput`](crate::output::GetEmailTemplateOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_name: std::option::Option<std::string::String>,
        pub(crate) template_content: std::option::Option<crate::model::EmailTemplateContent>,
    }
    impl Builder {
        /// <p>The name of the template.</p>
        pub fn template_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.template_name = Some(input.into());
            self
        }
        /// <p>The name of the template.</p>
        pub fn set_template_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.template_name = input;
            self
        }
        /// <p>The content of the email template, composed of a subject line, an HTML part, and a text-only part.</p>
        pub fn template_content(mut self, input: crate::model::EmailTemplateContent) -> Self {
            self.template_content = Some(input);
            self
        }
        /// <p>The content of the email template, composed of a subject line, an HTML part, and a text-only part.</p>
        pub fn set_template_content(
            mut self,
            input: std::option::Option<crate::model::EmailTemplateContent>,
        ) -> Self {
            self.template_content = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEmailTemplateOutput`](crate::output::GetEmailTemplateOutput)
        pub fn build(self) -> crate::output::GetEmailTemplateOutput {
            crate::output::GetEmailTemplateOutput {
                template_name: self.template_name,
                template_content: self.template_content,
            }
        }
    }
}
impl GetEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`GetEmailTemplateOutput`](crate::output::GetEmailTemplateOutput)
    pub fn builder() -> crate::output::get_email_template_output::Builder {
        crate::output::get_email_template_output::Builder::default()
    }
}

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

/// <p>Details about an email identity.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetEmailIdentityOutput {
    /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
    pub identity_type: std::option::Option<crate::model::IdentityType>,
    /// <p>The feedback forwarding configuration for the identity.</p>
    /// <p>If the value is <code>true</code>, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the <code>Return-Path</code> header of the original email.</p>
    /// <p>You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).</p>
    pub feedback_forwarding_status: bool,
    /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
    pub verified_for_sending_status: bool,
    /// <p>An object that contains information about the DKIM attributes for the identity.</p>
    pub dkim_attributes: std::option::Option<crate::model::DkimAttributes>,
    /// <p>An object that contains information about the Mail-From attributes for the email identity.</p>
    pub mail_from_attributes: std::option::Option<crate::model::MailFromAttributes>,
    /// <p>A map of policy names to policies.</p>
    pub policies:
        std::option::Option<std::collections::HashMap<std::string::String, std::string::String>>,
    /// <p>An array of objects that define the tags (keys and values) that are associated with the email identity.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>The configuration set used by default when sending from this identity.</p>
    pub configuration_set_name: std::option::Option<std::string::String>,
}
impl GetEmailIdentityOutput {
    /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
    pub fn identity_type(&self) -> std::option::Option<&crate::model::IdentityType> {
        self.identity_type.as_ref()
    }
    /// <p>The feedback forwarding configuration for the identity.</p>
    /// <p>If the value is <code>true</code>, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the <code>Return-Path</code> header of the original email.</p>
    /// <p>You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).</p>
    pub fn feedback_forwarding_status(&self) -> bool {
        self.feedback_forwarding_status
    }
    /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
    pub fn verified_for_sending_status(&self) -> bool {
        self.verified_for_sending_status
    }
    /// <p>An object that contains information about the DKIM attributes for the identity.</p>
    pub fn dkim_attributes(&self) -> std::option::Option<&crate::model::DkimAttributes> {
        self.dkim_attributes.as_ref()
    }
    /// <p>An object that contains information about the Mail-From attributes for the email identity.</p>
    pub fn mail_from_attributes(&self) -> std::option::Option<&crate::model::MailFromAttributes> {
        self.mail_from_attributes.as_ref()
    }
    /// <p>A map of policy names to policies.</p>
    pub fn policies(
        &self,
    ) -> std::option::Option<&std::collections::HashMap<std::string::String, std::string::String>>
    {
        self.policies.as_ref()
    }
    /// <p>An array of objects that define the tags (keys and values) that are associated with the email identity.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>The configuration set used by default when sending from this identity.</p>
    pub fn configuration_set_name(&self) -> std::option::Option<&str> {
        self.configuration_set_name.as_deref()
    }
}
impl std::fmt::Debug for GetEmailIdentityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetEmailIdentityOutput");
        formatter.field("identity_type", &self.identity_type);
        formatter.field(
            "feedback_forwarding_status",
            &self.feedback_forwarding_status,
        );
        formatter.field(
            "verified_for_sending_status",
            &self.verified_for_sending_status,
        );
        formatter.field("dkim_attributes", &self.dkim_attributes);
        formatter.field("mail_from_attributes", &self.mail_from_attributes);
        formatter.field("policies", &self.policies);
        formatter.field("tags", &self.tags);
        formatter.field("configuration_set_name", &self.configuration_set_name);
        formatter.finish()
    }
}
/// See [`GetEmailIdentityOutput`](crate::output::GetEmailIdentityOutput)
pub mod get_email_identity_output {
    /// A builder for [`GetEmailIdentityOutput`](crate::output::GetEmailIdentityOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) identity_type: std::option::Option<crate::model::IdentityType>,
        pub(crate) feedback_forwarding_status: std::option::Option<bool>,
        pub(crate) verified_for_sending_status: std::option::Option<bool>,
        pub(crate) dkim_attributes: std::option::Option<crate::model::DkimAttributes>,
        pub(crate) mail_from_attributes: std::option::Option<crate::model::MailFromAttributes>,
        pub(crate) policies: std::option::Option<
            std::collections::HashMap<std::string::String, std::string::String>,
        >,
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) configuration_set_name: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
        pub fn identity_type(mut self, input: crate::model::IdentityType) -> Self {
            self.identity_type = Some(input);
            self
        }
        /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
        pub fn set_identity_type(
            mut self,
            input: std::option::Option<crate::model::IdentityType>,
        ) -> Self {
            self.identity_type = input;
            self
        }
        /// <p>The feedback forwarding configuration for the identity.</p>
        /// <p>If the value is <code>true</code>, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the <code>Return-Path</code> header of the original email.</p>
        /// <p>You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).</p>
        pub fn feedback_forwarding_status(mut self, input: bool) -> Self {
            self.feedback_forwarding_status = Some(input);
            self
        }
        /// <p>The feedback forwarding configuration for the identity.</p>
        /// <p>If the value is <code>true</code>, you receive email notifications when bounce or complaint events occur. These notifications are sent to the address that you specified in the <code>Return-Path</code> header of the original email.</p>
        /// <p>You're required to have a method of tracking bounces and complaints. If you haven't set up another mechanism for receiving bounce or complaint notifications (for example, by setting up an event destination), you receive an email notification when these events occur (even if this setting is disabled).</p>
        pub fn set_feedback_forwarding_status(mut self, input: std::option::Option<bool>) -> Self {
            self.feedback_forwarding_status = input;
            self
        }
        /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
        pub fn verified_for_sending_status(mut self, input: bool) -> Self {
            self.verified_for_sending_status = Some(input);
            self
        }
        /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
        pub fn set_verified_for_sending_status(mut self, input: std::option::Option<bool>) -> Self {
            self.verified_for_sending_status = input;
            self
        }
        /// <p>An object that contains information about the DKIM attributes for the identity.</p>
        pub fn dkim_attributes(mut self, input: crate::model::DkimAttributes) -> Self {
            self.dkim_attributes = Some(input);
            self
        }
        /// <p>An object that contains information about the DKIM attributes for the identity.</p>
        pub fn set_dkim_attributes(
            mut self,
            input: std::option::Option<crate::model::DkimAttributes>,
        ) -> Self {
            self.dkim_attributes = input;
            self
        }
        /// <p>An object that contains information about the Mail-From attributes for the email identity.</p>
        pub fn mail_from_attributes(mut self, input: crate::model::MailFromAttributes) -> Self {
            self.mail_from_attributes = Some(input);
            self
        }
        /// <p>An object that contains information about the Mail-From attributes for the email identity.</p>
        pub fn set_mail_from_attributes(
            mut self,
            input: std::option::Option<crate::model::MailFromAttributes>,
        ) -> Self {
            self.mail_from_attributes = input;
            self
        }
        /// Adds a key-value pair to `policies`.
        ///
        /// To override the contents of this collection use [`set_policies`](Self::set_policies).
        ///
        /// <p>A map of policy names to policies.</p>
        pub fn policies(
            mut self,
            k: impl Into<std::string::String>,
            v: impl Into<std::string::String>,
        ) -> Self {
            let mut hash_map = self.policies.unwrap_or_default();
            hash_map.insert(k.into(), v.into());
            self.policies = Some(hash_map);
            self
        }
        /// <p>A map of policy names to policies.</p>
        pub fn set_policies(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<std::string::String, std::string::String>,
            >,
        ) -> Self {
            self.policies = input;
            self
        }
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>An array of objects that define the tags (keys and values) that are associated with the email identity.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>An array of objects that define the tags (keys and values) that are associated with the email identity.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>The configuration set used by default when sending from this identity.</p>
        pub fn configuration_set_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.configuration_set_name = Some(input.into());
            self
        }
        /// <p>The configuration set used by default when sending from this identity.</p>
        pub fn set_configuration_set_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.configuration_set_name = input;
            self
        }
        /// Consumes the builder and constructs a [`GetEmailIdentityOutput`](crate::output::GetEmailIdentityOutput)
        pub fn build(self) -> crate::output::GetEmailIdentityOutput {
            crate::output::GetEmailIdentityOutput {
                identity_type: self.identity_type,
                feedback_forwarding_status: self.feedback_forwarding_status.unwrap_or_default(),
                verified_for_sending_status: self.verified_for_sending_status.unwrap_or_default(),
                dkim_attributes: self.dkim_attributes,
                mail_from_attributes: self.mail_from_attributes,
                policies: self.policies,
                tags: self.tags,
                configuration_set_name: self.configuration_set_name,
            }
        }
    }
}
impl GetEmailIdentityOutput {
    /// Creates a new builder-style object to manufacture [`GetEmailIdentityOutput`](crate::output::GetEmailIdentityOutput)
    pub fn builder() -> crate::output::get_email_identity_output::Builder {
        crate::output::get_email_identity_output::Builder::default()
    }
}

/// <p>An object that includes statistics that are related to the domain that you specified.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDomainStatisticsReportOutput {
    /// <p>An object that contains deliverability metrics for the domain that you specified. The data in this object is a summary of all of the data that was collected from the <code>StartDate</code> to the <code>EndDate</code>.</p>
    pub overall_volume: std::option::Option<crate::model::OverallVolume>,
    /// <p>An object that contains deliverability metrics for the domain that you specified. This object contains data for each day, starting on the <code>StartDate</code> and ending on the <code>EndDate</code>.</p>
    pub daily_volumes: std::option::Option<std::vec::Vec<crate::model::DailyVolume>>,
}
impl GetDomainStatisticsReportOutput {
    /// <p>An object that contains deliverability metrics for the domain that you specified. The data in this object is a summary of all of the data that was collected from the <code>StartDate</code> to the <code>EndDate</code>.</p>
    pub fn overall_volume(&self) -> std::option::Option<&crate::model::OverallVolume> {
        self.overall_volume.as_ref()
    }
    /// <p>An object that contains deliverability metrics for the domain that you specified. This object contains data for each day, starting on the <code>StartDate</code> and ending on the <code>EndDate</code>.</p>
    pub fn daily_volumes(&self) -> std::option::Option<&[crate::model::DailyVolume]> {
        self.daily_volumes.as_deref()
    }
}
impl std::fmt::Debug for GetDomainStatisticsReportOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDomainStatisticsReportOutput");
        formatter.field("overall_volume", &self.overall_volume);
        formatter.field("daily_volumes", &self.daily_volumes);
        formatter.finish()
    }
}
/// See [`GetDomainStatisticsReportOutput`](crate::output::GetDomainStatisticsReportOutput)
pub mod get_domain_statistics_report_output {
    /// A builder for [`GetDomainStatisticsReportOutput`](crate::output::GetDomainStatisticsReportOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) overall_volume: std::option::Option<crate::model::OverallVolume>,
        pub(crate) daily_volumes: std::option::Option<std::vec::Vec<crate::model::DailyVolume>>,
    }
    impl Builder {
        /// <p>An object that contains deliverability metrics for the domain that you specified. The data in this object is a summary of all of the data that was collected from the <code>StartDate</code> to the <code>EndDate</code>.</p>
        pub fn overall_volume(mut self, input: crate::model::OverallVolume) -> Self {
            self.overall_volume = Some(input);
            self
        }
        /// <p>An object that contains deliverability metrics for the domain that you specified. The data in this object is a summary of all of the data that was collected from the <code>StartDate</code> to the <code>EndDate</code>.</p>
        pub fn set_overall_volume(
            mut self,
            input: std::option::Option<crate::model::OverallVolume>,
        ) -> Self {
            self.overall_volume = input;
            self
        }
        /// Appends an item to `daily_volumes`.
        ///
        /// To override the contents of this collection use [`set_daily_volumes`](Self::set_daily_volumes).
        ///
        /// <p>An object that contains deliverability metrics for the domain that you specified. This object contains data for each day, starting on the <code>StartDate</code> and ending on the <code>EndDate</code>.</p>
        pub fn daily_volumes(mut self, input: crate::model::DailyVolume) -> Self {
            let mut v = self.daily_volumes.unwrap_or_default();
            v.push(input);
            self.daily_volumes = Some(v);
            self
        }
        /// <p>An object that contains deliverability metrics for the domain that you specified. This object contains data for each day, starting on the <code>StartDate</code> and ending on the <code>EndDate</code>.</p>
        pub fn set_daily_volumes(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DailyVolume>>,
        ) -> Self {
            self.daily_volumes = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDomainStatisticsReportOutput`](crate::output::GetDomainStatisticsReportOutput)
        pub fn build(self) -> crate::output::GetDomainStatisticsReportOutput {
            crate::output::GetDomainStatisticsReportOutput {
                overall_volume: self.overall_volume,
                daily_volumes: self.daily_volumes,
            }
        }
    }
}
impl GetDomainStatisticsReportOutput {
    /// Creates a new builder-style object to manufacture [`GetDomainStatisticsReportOutput`](crate::output::GetDomainStatisticsReportOutput)
    pub fn builder() -> crate::output::get_domain_statistics_report_output::Builder {
        crate::output::get_domain_statistics_report_output::Builder::default()
    }
}

/// <p>An object that contains all the deliverability data for a specific campaign. This data is available for a campaign only if the campaign sent email by using a domain that the Deliverability dashboard is enabled for.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDomainDeliverabilityCampaignOutput {
    /// <p>An object that contains the deliverability data for the campaign.</p>
    pub domain_deliverability_campaign:
        std::option::Option<crate::model::DomainDeliverabilityCampaign>,
}
impl GetDomainDeliverabilityCampaignOutput {
    /// <p>An object that contains the deliverability data for the campaign.</p>
    pub fn domain_deliverability_campaign(
        &self,
    ) -> std::option::Option<&crate::model::DomainDeliverabilityCampaign> {
        self.domain_deliverability_campaign.as_ref()
    }
}
impl std::fmt::Debug for GetDomainDeliverabilityCampaignOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDomainDeliverabilityCampaignOutput");
        formatter.field(
            "domain_deliverability_campaign",
            &self.domain_deliverability_campaign,
        );
        formatter.finish()
    }
}
/// See [`GetDomainDeliverabilityCampaignOutput`](crate::output::GetDomainDeliverabilityCampaignOutput)
pub mod get_domain_deliverability_campaign_output {
    /// A builder for [`GetDomainDeliverabilityCampaignOutput`](crate::output::GetDomainDeliverabilityCampaignOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) domain_deliverability_campaign:
            std::option::Option<crate::model::DomainDeliverabilityCampaign>,
    }
    impl Builder {
        /// <p>An object that contains the deliverability data for the campaign.</p>
        pub fn domain_deliverability_campaign(
            mut self,
            input: crate::model::DomainDeliverabilityCampaign,
        ) -> Self {
            self.domain_deliverability_campaign = Some(input);
            self
        }
        /// <p>An object that contains the deliverability data for the campaign.</p>
        pub fn set_domain_deliverability_campaign(
            mut self,
            input: std::option::Option<crate::model::DomainDeliverabilityCampaign>,
        ) -> Self {
            self.domain_deliverability_campaign = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDomainDeliverabilityCampaignOutput`](crate::output::GetDomainDeliverabilityCampaignOutput)
        pub fn build(self) -> crate::output::GetDomainDeliverabilityCampaignOutput {
            crate::output::GetDomainDeliverabilityCampaignOutput {
                domain_deliverability_campaign: self.domain_deliverability_campaign,
            }
        }
    }
}
impl GetDomainDeliverabilityCampaignOutput {
    /// Creates a new builder-style object to manufacture [`GetDomainDeliverabilityCampaignOutput`](crate::output::GetDomainDeliverabilityCampaignOutput)
    pub fn builder() -> crate::output::get_domain_deliverability_campaign_output::Builder {
        crate::output::get_domain_deliverability_campaign_output::Builder::default()
    }
}

/// <p>The results of the predictive inbox placement test.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeliverabilityTestReportOutput {
    /// <p>An object that contains the results of the predictive inbox placement test.</p>
    pub deliverability_test_report: std::option::Option<crate::model::DeliverabilityTestReport>,
    /// <p>An object that specifies how many test messages that were sent during the predictive inbox placement test were delivered to recipients' inboxes, how many were sent to recipients' spam folders, and how many weren't delivered.</p>
    pub overall_placement: std::option::Option<crate::model::PlacementStatistics>,
    /// <p>An object that describes how the test email was handled by several email providers, including Gmail, Hotmail, Yahoo, AOL, and others.</p>
    pub isp_placements: std::option::Option<std::vec::Vec<crate::model::IspPlacement>>,
    /// <p>An object that contains the message that you sent when you performed this predictive inbox placement test.</p>
    pub message: std::option::Option<std::string::String>,
    /// <p>An array of objects that define the tags (keys and values) that are associated with the predictive inbox placement test.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl GetDeliverabilityTestReportOutput {
    /// <p>An object that contains the results of the predictive inbox placement test.</p>
    pub fn deliverability_test_report(
        &self,
    ) -> std::option::Option<&crate::model::DeliverabilityTestReport> {
        self.deliverability_test_report.as_ref()
    }
    /// <p>An object that specifies how many test messages that were sent during the predictive inbox placement test were delivered to recipients' inboxes, how many were sent to recipients' spam folders, and how many weren't delivered.</p>
    pub fn overall_placement(&self) -> std::option::Option<&crate::model::PlacementStatistics> {
        self.overall_placement.as_ref()
    }
    /// <p>An object that describes how the test email was handled by several email providers, including Gmail, Hotmail, Yahoo, AOL, and others.</p>
    pub fn isp_placements(&self) -> std::option::Option<&[crate::model::IspPlacement]> {
        self.isp_placements.as_deref()
    }
    /// <p>An object that contains the message that you sent when you performed this predictive inbox placement test.</p>
    pub fn message(&self) -> std::option::Option<&str> {
        self.message.as_deref()
    }
    /// <p>An array of objects that define the tags (keys and values) that are associated with the predictive inbox placement test.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
}
impl std::fmt::Debug for GetDeliverabilityTestReportOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDeliverabilityTestReportOutput");
        formatter.field(
            "deliverability_test_report",
            &self.deliverability_test_report,
        );
        formatter.field("overall_placement", &self.overall_placement);
        formatter.field("isp_placements", &self.isp_placements);
        formatter.field("message", &self.message);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetDeliverabilityTestReportOutput`](crate::output::GetDeliverabilityTestReportOutput)
pub mod get_deliverability_test_report_output {
    /// A builder for [`GetDeliverabilityTestReportOutput`](crate::output::GetDeliverabilityTestReportOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) deliverability_test_report:
            std::option::Option<crate::model::DeliverabilityTestReport>,
        pub(crate) overall_placement: std::option::Option<crate::model::PlacementStatistics>,
        pub(crate) isp_placements: std::option::Option<std::vec::Vec<crate::model::IspPlacement>>,
        pub(crate) message: std::option::Option<std::string::String>,
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// <p>An object that contains the results of the predictive inbox placement test.</p>
        pub fn deliverability_test_report(
            mut self,
            input: crate::model::DeliverabilityTestReport,
        ) -> Self {
            self.deliverability_test_report = Some(input);
            self
        }
        /// <p>An object that contains the results of the predictive inbox placement test.</p>
        pub fn set_deliverability_test_report(
            mut self,
            input: std::option::Option<crate::model::DeliverabilityTestReport>,
        ) -> Self {
            self.deliverability_test_report = input;
            self
        }
        /// <p>An object that specifies how many test messages that were sent during the predictive inbox placement test were delivered to recipients' inboxes, how many were sent to recipients' spam folders, and how many weren't delivered.</p>
        pub fn overall_placement(mut self, input: crate::model::PlacementStatistics) -> Self {
            self.overall_placement = Some(input);
            self
        }
        /// <p>An object that specifies how many test messages that were sent during the predictive inbox placement test were delivered to recipients' inboxes, how many were sent to recipients' spam folders, and how many weren't delivered.</p>
        pub fn set_overall_placement(
            mut self,
            input: std::option::Option<crate::model::PlacementStatistics>,
        ) -> Self {
            self.overall_placement = input;
            self
        }
        /// Appends an item to `isp_placements`.
        ///
        /// To override the contents of this collection use [`set_isp_placements`](Self::set_isp_placements).
        ///
        /// <p>An object that describes how the test email was handled by several email providers, including Gmail, Hotmail, Yahoo, AOL, and others.</p>
        pub fn isp_placements(mut self, input: crate::model::IspPlacement) -> Self {
            let mut v = self.isp_placements.unwrap_or_default();
            v.push(input);
            self.isp_placements = Some(v);
            self
        }
        /// <p>An object that describes how the test email was handled by several email providers, including Gmail, Hotmail, Yahoo, AOL, and others.</p>
        pub fn set_isp_placements(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::IspPlacement>>,
        ) -> Self {
            self.isp_placements = input;
            self
        }
        /// <p>An object that contains the message that you sent when you performed this predictive inbox placement test.</p>
        pub fn message(mut self, input: impl Into<std::string::String>) -> Self {
            self.message = Some(input.into());
            self
        }
        /// <p>An object that contains the message that you sent when you performed this predictive inbox placement test.</p>
        pub fn set_message(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.message = input;
            self
        }
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>An array of objects that define the tags (keys and values) that are associated with the predictive inbox placement test.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>An array of objects that define the tags (keys and values) that are associated with the predictive inbox placement test.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDeliverabilityTestReportOutput`](crate::output::GetDeliverabilityTestReportOutput)
        pub fn build(self) -> crate::output::GetDeliverabilityTestReportOutput {
            crate::output::GetDeliverabilityTestReportOutput {
                deliverability_test_report: self.deliverability_test_report,
                overall_placement: self.overall_placement,
                isp_placements: self.isp_placements,
                message: self.message,
                tags: self.tags,
            }
        }
    }
}
impl GetDeliverabilityTestReportOutput {
    /// Creates a new builder-style object to manufacture [`GetDeliverabilityTestReportOutput`](crate::output::GetDeliverabilityTestReportOutput)
    pub fn builder() -> crate::output::get_deliverability_test_report_output::Builder {
        crate::output::get_deliverability_test_report_output::Builder::default()
    }
}

/// <p>An object that shows the status of the Deliverability dashboard.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDeliverabilityDashboardOptionsOutput {
    /// <p>Specifies whether the Deliverability dashboard is enabled. If this value is <code>true</code>, the dashboard is enabled.</p>
    pub dashboard_enabled: bool,
    /// <p>The date, in Unix time format, when your current subscription to the Deliverability dashboard is scheduled to expire, if your subscription is scheduled to expire at the end of the current calendar month. This value is null if you have an active subscription that isn’t due to expire at the end of the month.</p>
    pub subscription_expiry_date: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The current status of your Deliverability dashboard subscription. If this value is <code>PENDING_EXPIRATION</code>, your subscription is scheduled to expire at the end of the current calendar month.</p>
    pub account_status: std::option::Option<crate::model::DeliverabilityDashboardAccountStatus>,
    /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that isn’t scheduled to expire at the end of the current calendar month.</p>
    pub active_subscribed_domains:
        std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>>,
    /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that's scheduled to expire at the end of the current calendar month.</p>
    pub pending_expiration_subscribed_domains:
        std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>>,
}
impl GetDeliverabilityDashboardOptionsOutput {
    /// <p>Specifies whether the Deliverability dashboard is enabled. If this value is <code>true</code>, the dashboard is enabled.</p>
    pub fn dashboard_enabled(&self) -> bool {
        self.dashboard_enabled
    }
    /// <p>The date, in Unix time format, when your current subscription to the Deliverability dashboard is scheduled to expire, if your subscription is scheduled to expire at the end of the current calendar month. This value is null if you have an active subscription that isn’t due to expire at the end of the month.</p>
    pub fn subscription_expiry_date(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.subscription_expiry_date.as_ref()
    }
    /// <p>The current status of your Deliverability dashboard subscription. If this value is <code>PENDING_EXPIRATION</code>, your subscription is scheduled to expire at the end of the current calendar month.</p>
    pub fn account_status(
        &self,
    ) -> std::option::Option<&crate::model::DeliverabilityDashboardAccountStatus> {
        self.account_status.as_ref()
    }
    /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that isn’t scheduled to expire at the end of the current calendar month.</p>
    pub fn active_subscribed_domains(
        &self,
    ) -> std::option::Option<&[crate::model::DomainDeliverabilityTrackingOption]> {
        self.active_subscribed_domains.as_deref()
    }
    /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that's scheduled to expire at the end of the current calendar month.</p>
    pub fn pending_expiration_subscribed_domains(
        &self,
    ) -> std::option::Option<&[crate::model::DomainDeliverabilityTrackingOption]> {
        self.pending_expiration_subscribed_domains.as_deref()
    }
}
impl std::fmt::Debug for GetDeliverabilityDashboardOptionsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDeliverabilityDashboardOptionsOutput");
        formatter.field("dashboard_enabled", &self.dashboard_enabled);
        formatter.field("subscription_expiry_date", &self.subscription_expiry_date);
        formatter.field("account_status", &self.account_status);
        formatter.field("active_subscribed_domains", &self.active_subscribed_domains);
        formatter.field(
            "pending_expiration_subscribed_domains",
            &self.pending_expiration_subscribed_domains,
        );
        formatter.finish()
    }
}
/// See [`GetDeliverabilityDashboardOptionsOutput`](crate::output::GetDeliverabilityDashboardOptionsOutput)
pub mod get_deliverability_dashboard_options_output {
    /// A builder for [`GetDeliverabilityDashboardOptionsOutput`](crate::output::GetDeliverabilityDashboardOptionsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dashboard_enabled: std::option::Option<bool>,
        pub(crate) subscription_expiry_date: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) account_status:
            std::option::Option<crate::model::DeliverabilityDashboardAccountStatus>,
        pub(crate) active_subscribed_domains:
            std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>>,
        pub(crate) pending_expiration_subscribed_domains:
            std::option::Option<std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>>,
    }
    impl Builder {
        /// <p>Specifies whether the Deliverability dashboard is enabled. If this value is <code>true</code>, the dashboard is enabled.</p>
        pub fn dashboard_enabled(mut self, input: bool) -> Self {
            self.dashboard_enabled = Some(input);
            self
        }
        /// <p>Specifies whether the Deliverability dashboard is enabled. If this value is <code>true</code>, the dashboard is enabled.</p>
        pub fn set_dashboard_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.dashboard_enabled = input;
            self
        }
        /// <p>The date, in Unix time format, when your current subscription to the Deliverability dashboard is scheduled to expire, if your subscription is scheduled to expire at the end of the current calendar month. This value is null if you have an active subscription that isn’t due to expire at the end of the month.</p>
        pub fn subscription_expiry_date(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.subscription_expiry_date = Some(input);
            self
        }
        /// <p>The date, in Unix time format, when your current subscription to the Deliverability dashboard is scheduled to expire, if your subscription is scheduled to expire at the end of the current calendar month. This value is null if you have an active subscription that isn’t due to expire at the end of the month.</p>
        pub fn set_subscription_expiry_date(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.subscription_expiry_date = input;
            self
        }
        /// <p>The current status of your Deliverability dashboard subscription. If this value is <code>PENDING_EXPIRATION</code>, your subscription is scheduled to expire at the end of the current calendar month.</p>
        pub fn account_status(
            mut self,
            input: crate::model::DeliverabilityDashboardAccountStatus,
        ) -> Self {
            self.account_status = Some(input);
            self
        }
        /// <p>The current status of your Deliverability dashboard subscription. If this value is <code>PENDING_EXPIRATION</code>, your subscription is scheduled to expire at the end of the current calendar month.</p>
        pub fn set_account_status(
            mut self,
            input: std::option::Option<crate::model::DeliverabilityDashboardAccountStatus>,
        ) -> Self {
            self.account_status = input;
            self
        }
        /// Appends an item to `active_subscribed_domains`.
        ///
        /// To override the contents of this collection use [`set_active_subscribed_domains`](Self::set_active_subscribed_domains).
        ///
        /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that isn’t scheduled to expire at the end of the current calendar month.</p>
        pub fn active_subscribed_domains(
            mut self,
            input: crate::model::DomainDeliverabilityTrackingOption,
        ) -> Self {
            let mut v = self.active_subscribed_domains.unwrap_or_default();
            v.push(input);
            self.active_subscribed_domains = Some(v);
            self
        }
        /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that isn’t scheduled to expire at the end of the current calendar month.</p>
        pub fn set_active_subscribed_domains(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>,
            >,
        ) -> Self {
            self.active_subscribed_domains = input;
            self
        }
        /// Appends an item to `pending_expiration_subscribed_domains`.
        ///
        /// To override the contents of this collection use [`set_pending_expiration_subscribed_domains`](Self::set_pending_expiration_subscribed_domains).
        ///
        /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that's scheduled to expire at the end of the current calendar month.</p>
        pub fn pending_expiration_subscribed_domains(
            mut self,
            input: crate::model::DomainDeliverabilityTrackingOption,
        ) -> Self {
            let mut v = self
                .pending_expiration_subscribed_domains
                .unwrap_or_default();
            v.push(input);
            self.pending_expiration_subscribed_domains = Some(v);
            self
        }
        /// <p>An array of objects, one for each verified domain that you use to send email and currently has an active Deliverability dashboard subscription that's scheduled to expire at the end of the current calendar month.</p>
        pub fn set_pending_expiration_subscribed_domains(
            mut self,
            input: std::option::Option<
                std::vec::Vec<crate::model::DomainDeliverabilityTrackingOption>,
            >,
        ) -> Self {
            self.pending_expiration_subscribed_domains = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDeliverabilityDashboardOptionsOutput`](crate::output::GetDeliverabilityDashboardOptionsOutput)
        pub fn build(self) -> crate::output::GetDeliverabilityDashboardOptionsOutput {
            crate::output::GetDeliverabilityDashboardOptionsOutput {
                dashboard_enabled: self.dashboard_enabled.unwrap_or_default(),
                subscription_expiry_date: self.subscription_expiry_date,
                account_status: self.account_status,
                active_subscribed_domains: self.active_subscribed_domains,
                pending_expiration_subscribed_domains: self.pending_expiration_subscribed_domains,
            }
        }
    }
}
impl GetDeliverabilityDashboardOptionsOutput {
    /// Creates a new builder-style object to manufacture [`GetDeliverabilityDashboardOptionsOutput`](crate::output::GetDeliverabilityDashboardOptionsOutput)
    pub fn builder() -> crate::output::get_deliverability_dashboard_options_output::Builder {
        crate::output::get_deliverability_dashboard_options_output::Builder::default()
    }
}

/// <p>Information about the dedicated IP addresses that are associated with your Amazon Web Services account.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDedicatedIpsOutput {
    /// <p>A list of dedicated IP addresses that are associated with your Amazon Web Services account.</p>
    pub dedicated_ips: std::option::Option<std::vec::Vec<crate::model::DedicatedIp>>,
    /// <p>A token that indicates that there are additional dedicated IP addresses to list. To view additional addresses, issue another request to <code>GetDedicatedIps</code>, passing this token in the <code>NextToken</code> parameter.</p>
    pub next_token: std::option::Option<std::string::String>,
}
impl GetDedicatedIpsOutput {
    /// <p>A list of dedicated IP addresses that are associated with your Amazon Web Services account.</p>
    pub fn dedicated_ips(&self) -> std::option::Option<&[crate::model::DedicatedIp]> {
        self.dedicated_ips.as_deref()
    }
    /// <p>A token that indicates that there are additional dedicated IP addresses to list. To view additional addresses, issue another request to <code>GetDedicatedIps</code>, passing this token in the <code>NextToken</code> parameter.</p>
    pub fn next_token(&self) -> std::option::Option<&str> {
        self.next_token.as_deref()
    }
}
impl std::fmt::Debug for GetDedicatedIpsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDedicatedIpsOutput");
        formatter.field("dedicated_ips", &self.dedicated_ips);
        formatter.field("next_token", &self.next_token);
        formatter.finish()
    }
}
/// See [`GetDedicatedIpsOutput`](crate::output::GetDedicatedIpsOutput)
pub mod get_dedicated_ips_output {
    /// A builder for [`GetDedicatedIpsOutput`](crate::output::GetDedicatedIpsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dedicated_ips: std::option::Option<std::vec::Vec<crate::model::DedicatedIp>>,
        pub(crate) next_token: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// Appends an item to `dedicated_ips`.
        ///
        /// To override the contents of this collection use [`set_dedicated_ips`](Self::set_dedicated_ips).
        ///
        /// <p>A list of dedicated IP addresses that are associated with your Amazon Web Services account.</p>
        pub fn dedicated_ips(mut self, input: crate::model::DedicatedIp) -> Self {
            let mut v = self.dedicated_ips.unwrap_or_default();
            v.push(input);
            self.dedicated_ips = Some(v);
            self
        }
        /// <p>A list of dedicated IP addresses that are associated with your Amazon Web Services account.</p>
        pub fn set_dedicated_ips(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::DedicatedIp>>,
        ) -> Self {
            self.dedicated_ips = input;
            self
        }
        /// <p>A token that indicates that there are additional dedicated IP addresses to list. To view additional addresses, issue another request to <code>GetDedicatedIps</code>, passing this token in the <code>NextToken</code> parameter.</p>
        pub fn next_token(mut self, input: impl Into<std::string::String>) -> Self {
            self.next_token = Some(input.into());
            self
        }
        /// <p>A token that indicates that there are additional dedicated IP addresses to list. To view additional addresses, issue another request to <code>GetDedicatedIps</code>, passing this token in the <code>NextToken</code> parameter.</p>
        pub fn set_next_token(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.next_token = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDedicatedIpsOutput`](crate::output::GetDedicatedIpsOutput)
        pub fn build(self) -> crate::output::GetDedicatedIpsOutput {
            crate::output::GetDedicatedIpsOutput {
                dedicated_ips: self.dedicated_ips,
                next_token: self.next_token,
            }
        }
    }
}
impl GetDedicatedIpsOutput {
    /// Creates a new builder-style object to manufacture [`GetDedicatedIpsOutput`](crate::output::GetDedicatedIpsOutput)
    pub fn builder() -> crate::output::get_dedicated_ips_output::Builder {
        crate::output::get_dedicated_ips_output::Builder::default()
    }
}

/// <p>Information about a dedicated IP address.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetDedicatedIpOutput {
    /// <p>An object that contains information about a dedicated IP address.</p>
    pub dedicated_ip: std::option::Option<crate::model::DedicatedIp>,
}
impl GetDedicatedIpOutput {
    /// <p>An object that contains information about a dedicated IP address.</p>
    pub fn dedicated_ip(&self) -> std::option::Option<&crate::model::DedicatedIp> {
        self.dedicated_ip.as_ref()
    }
}
impl std::fmt::Debug for GetDedicatedIpOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetDedicatedIpOutput");
        formatter.field("dedicated_ip", &self.dedicated_ip);
        formatter.finish()
    }
}
/// See [`GetDedicatedIpOutput`](crate::output::GetDedicatedIpOutput)
pub mod get_dedicated_ip_output {
    /// A builder for [`GetDedicatedIpOutput`](crate::output::GetDedicatedIpOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dedicated_ip: std::option::Option<crate::model::DedicatedIp>,
    }
    impl Builder {
        /// <p>An object that contains information about a dedicated IP address.</p>
        pub fn dedicated_ip(mut self, input: crate::model::DedicatedIp) -> Self {
            self.dedicated_ip = Some(input);
            self
        }
        /// <p>An object that contains information about a dedicated IP address.</p>
        pub fn set_dedicated_ip(
            mut self,
            input: std::option::Option<crate::model::DedicatedIp>,
        ) -> Self {
            self.dedicated_ip = input;
            self
        }
        /// Consumes the builder and constructs a [`GetDedicatedIpOutput`](crate::output::GetDedicatedIpOutput)
        pub fn build(self) -> crate::output::GetDedicatedIpOutput {
            crate::output::GetDedicatedIpOutput {
                dedicated_ip: self.dedicated_ip,
            }
        }
    }
}
impl GetDedicatedIpOutput {
    /// Creates a new builder-style object to manufacture [`GetDedicatedIpOutput`](crate::output::GetDedicatedIpOutput)
    pub fn builder() -> crate::output::get_dedicated_ip_output::Builder {
        crate::output::get_dedicated_ip_output::Builder::default()
    }
}

/// <p>The following elements are returned by the service.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetCustomVerificationEmailTemplateOutput {
    /// <p>The name of the custom verification email template.</p>
    pub template_name: std::option::Option<std::string::String>,
    /// <p>The email address that the custom verification email is sent from.</p>
    pub from_email_address: std::option::Option<std::string::String>,
    /// <p>The subject line of the custom verification email.</p>
    pub template_subject: std::option::Option<std::string::String>,
    /// <p>The content of the custom verification email.</p>
    pub template_content: std::option::Option<std::string::String>,
    /// <p>The URL that the recipient of the verification email is sent to if his or her address is successfully verified.</p>
    pub success_redirection_url: std::option::Option<std::string::String>,
    /// <p>The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.</p>
    pub failure_redirection_url: std::option::Option<std::string::String>,
}
impl GetCustomVerificationEmailTemplateOutput {
    /// <p>The name of the custom verification email template.</p>
    pub fn template_name(&self) -> std::option::Option<&str> {
        self.template_name.as_deref()
    }
    /// <p>The email address that the custom verification email is sent from.</p>
    pub fn from_email_address(&self) -> std::option::Option<&str> {
        self.from_email_address.as_deref()
    }
    /// <p>The subject line of the custom verification email.</p>
    pub fn template_subject(&self) -> std::option::Option<&str> {
        self.template_subject.as_deref()
    }
    /// <p>The content of the custom verification email.</p>
    pub fn template_content(&self) -> std::option::Option<&str> {
        self.template_content.as_deref()
    }
    /// <p>The URL that the recipient of the verification email is sent to if his or her address is successfully verified.</p>
    pub fn success_redirection_url(&self) -> std::option::Option<&str> {
        self.success_redirection_url.as_deref()
    }
    /// <p>The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.</p>
    pub fn failure_redirection_url(&self) -> std::option::Option<&str> {
        self.failure_redirection_url.as_deref()
    }
}
impl std::fmt::Debug for GetCustomVerificationEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetCustomVerificationEmailTemplateOutput");
        formatter.field("template_name", &self.template_name);
        formatter.field("from_email_address", &self.from_email_address);
        formatter.field("template_subject", &self.template_subject);
        formatter.field("template_content", &self.template_content);
        formatter.field("success_redirection_url", &self.success_redirection_url);
        formatter.field("failure_redirection_url", &self.failure_redirection_url);
        formatter.finish()
    }
}
/// See [`GetCustomVerificationEmailTemplateOutput`](crate::output::GetCustomVerificationEmailTemplateOutput)
pub mod get_custom_verification_email_template_output {
    /// A builder for [`GetCustomVerificationEmailTemplateOutput`](crate::output::GetCustomVerificationEmailTemplateOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) template_name: std::option::Option<std::string::String>,
        pub(crate) from_email_address: std::option::Option<std::string::String>,
        pub(crate) template_subject: std::option::Option<std::string::String>,
        pub(crate) template_content: std::option::Option<std::string::String>,
        pub(crate) success_redirection_url: std::option::Option<std::string::String>,
        pub(crate) failure_redirection_url: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>The name of the custom verification email template.</p>
        pub fn template_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.template_name = Some(input.into());
            self
        }
        /// <p>The name of the custom verification email template.</p>
        pub fn set_template_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.template_name = input;
            self
        }
        /// <p>The email address that the custom verification email is sent from.</p>
        pub fn from_email_address(mut self, input: impl Into<std::string::String>) -> Self {
            self.from_email_address = Some(input.into());
            self
        }
        /// <p>The email address that the custom verification email is sent from.</p>
        pub fn set_from_email_address(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.from_email_address = input;
            self
        }
        /// <p>The subject line of the custom verification email.</p>
        pub fn template_subject(mut self, input: impl Into<std::string::String>) -> Self {
            self.template_subject = Some(input.into());
            self
        }
        /// <p>The subject line of the custom verification email.</p>
        pub fn set_template_subject(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.template_subject = input;
            self
        }
        /// <p>The content of the custom verification email.</p>
        pub fn template_content(mut self, input: impl Into<std::string::String>) -> Self {
            self.template_content = Some(input.into());
            self
        }
        /// <p>The content of the custom verification email.</p>
        pub fn set_template_content(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.template_content = input;
            self
        }
        /// <p>The URL that the recipient of the verification email is sent to if his or her address is successfully verified.</p>
        pub fn success_redirection_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.success_redirection_url = Some(input.into());
            self
        }
        /// <p>The URL that the recipient of the verification email is sent to if his or her address is successfully verified.</p>
        pub fn set_success_redirection_url(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.success_redirection_url = input;
            self
        }
        /// <p>The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.</p>
        pub fn failure_redirection_url(mut self, input: impl Into<std::string::String>) -> Self {
            self.failure_redirection_url = Some(input.into());
            self
        }
        /// <p>The URL that the recipient of the verification email is sent to if his or her address is not successfully verified.</p>
        pub fn set_failure_redirection_url(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.failure_redirection_url = input;
            self
        }
        /// Consumes the builder and constructs a [`GetCustomVerificationEmailTemplateOutput`](crate::output::GetCustomVerificationEmailTemplateOutput)
        pub fn build(self) -> crate::output::GetCustomVerificationEmailTemplateOutput {
            crate::output::GetCustomVerificationEmailTemplateOutput {
                template_name: self.template_name,
                from_email_address: self.from_email_address,
                template_subject: self.template_subject,
                template_content: self.template_content,
                success_redirection_url: self.success_redirection_url,
                failure_redirection_url: self.failure_redirection_url,
            }
        }
    }
}
impl GetCustomVerificationEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`GetCustomVerificationEmailTemplateOutput`](crate::output::GetCustomVerificationEmailTemplateOutput)
    pub fn builder() -> crate::output::get_custom_verification_email_template_output::Builder {
        crate::output::get_custom_verification_email_template_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetContactListOutput {
    /// <p>The name of the contact list.</p>
    pub contact_list_name: std::option::Option<std::string::String>,
    /// <p>An interest group, theme, or label within a list. A contact list can have multiple topics.</p>
    pub topics: std::option::Option<std::vec::Vec<crate::model::Topic>>,
    /// <p>A description of what the contact list is about.</p>
    pub description: std::option::Option<std::string::String>,
    /// <p>A timestamp noting when the contact list was created.</p>
    pub created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>A timestamp noting the last time the contact list was updated.</p>
    pub last_updated_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>The tags associated with a contact list.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
}
impl GetContactListOutput {
    /// <p>The name of the contact list.</p>
    pub fn contact_list_name(&self) -> std::option::Option<&str> {
        self.contact_list_name.as_deref()
    }
    /// <p>An interest group, theme, or label within a list. A contact list can have multiple topics.</p>
    pub fn topics(&self) -> std::option::Option<&[crate::model::Topic]> {
        self.topics.as_deref()
    }
    /// <p>A description of what the contact list is about.</p>
    pub fn description(&self) -> std::option::Option<&str> {
        self.description.as_deref()
    }
    /// <p>A timestamp noting when the contact list was created.</p>
    pub fn created_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_timestamp.as_ref()
    }
    /// <p>A timestamp noting the last time the contact list was updated.</p>
    pub fn last_updated_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_updated_timestamp.as_ref()
    }
    /// <p>The tags associated with a contact list.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
}
impl std::fmt::Debug for GetContactListOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetContactListOutput");
        formatter.field("contact_list_name", &self.contact_list_name);
        formatter.field("topics", &self.topics);
        formatter.field("description", &self.description);
        formatter.field("created_timestamp", &self.created_timestamp);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.field("tags", &self.tags);
        formatter.finish()
    }
}
/// See [`GetContactListOutput`](crate::output::GetContactListOutput)
pub mod get_contact_list_output {
    /// A builder for [`GetContactListOutput`](crate::output::GetContactListOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) contact_list_name: std::option::Option<std::string::String>,
        pub(crate) topics: std::option::Option<std::vec::Vec<crate::model::Topic>>,
        pub(crate) description: std::option::Option<std::string::String>,
        pub(crate) created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) last_updated_timestamp: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    }
    impl Builder {
        /// <p>The name of the contact list.</p>
        pub fn contact_list_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.contact_list_name = Some(input.into());
            self
        }
        /// <p>The name of the contact list.</p>
        pub fn set_contact_list_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.contact_list_name = input;
            self
        }
        /// Appends an item to `topics`.
        ///
        /// To override the contents of this collection use [`set_topics`](Self::set_topics).
        ///
        /// <p>An interest group, theme, or label within a list. A contact list can have multiple topics.</p>
        pub fn topics(mut self, input: crate::model::Topic) -> Self {
            let mut v = self.topics.unwrap_or_default();
            v.push(input);
            self.topics = Some(v);
            self
        }
        /// <p>An interest group, theme, or label within a list. A contact list can have multiple topics.</p>
        pub fn set_topics(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Topic>>,
        ) -> Self {
            self.topics = input;
            self
        }
        /// <p>A description of what the contact list is about.</p>
        pub fn description(mut self, input: impl Into<std::string::String>) -> Self {
            self.description = Some(input.into());
            self
        }
        /// <p>A description of what the contact list is about.</p>
        pub fn set_description(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.description = input;
            self
        }
        /// <p>A timestamp noting when the contact list was created.</p>
        pub fn created_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_timestamp = Some(input);
            self
        }
        /// <p>A timestamp noting when the contact list was created.</p>
        pub fn set_created_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_timestamp = input;
            self
        }
        /// <p>A timestamp noting the last time the contact list was updated.</p>
        pub fn last_updated_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_updated_timestamp = Some(input);
            self
        }
        /// <p>A timestamp noting the last time the contact list was updated.</p>
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>The tags associated with a contact list.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>The tags associated with a contact list.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// Consumes the builder and constructs a [`GetContactListOutput`](crate::output::GetContactListOutput)
        pub fn build(self) -> crate::output::GetContactListOutput {
            crate::output::GetContactListOutput {
                contact_list_name: self.contact_list_name,
                topics: self.topics,
                description: self.description,
                created_timestamp: self.created_timestamp,
                last_updated_timestamp: self.last_updated_timestamp,
                tags: self.tags,
            }
        }
    }
}
impl GetContactListOutput {
    /// Creates a new builder-style object to manufacture [`GetContactListOutput`](crate::output::GetContactListOutput)
    pub fn builder() -> crate::output::get_contact_list_output::Builder {
        crate::output::get_contact_list_output::Builder::default()
    }
}

#[allow(missing_docs)] // documentation missing in model
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetContactOutput {
    /// <p>The name of the contact list to which the contact belongs.</p>
    pub contact_list_name: std::option::Option<std::string::String>,
    /// <p>The contact's email addres.</p>
    pub email_address: std::option::Option<std::string::String>,
    /// <p>The contact's preference for being opted-in to or opted-out of a topic.&gt;</p>
    pub topic_preferences: std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
    /// <p>The default topic preferences applied to the contact.</p>
    pub topic_default_preferences:
        std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
    /// <p>A boolean value status noting if the contact is unsubscribed from all contact list topics.</p>
    pub unsubscribe_all: bool,
    /// <p>The attribute data attached to a contact.</p>
    pub attributes_data: std::option::Option<std::string::String>,
    /// <p>A timestamp noting when the contact was created.</p>
    pub created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    /// <p>A timestamp noting the last time the contact's information was updated.</p>
    pub last_updated_timestamp: std::option::Option<aws_smithy_types::DateTime>,
}
impl GetContactOutput {
    /// <p>The name of the contact list to which the contact belongs.</p>
    pub fn contact_list_name(&self) -> std::option::Option<&str> {
        self.contact_list_name.as_deref()
    }
    /// <p>The contact's email addres.</p>
    pub fn email_address(&self) -> std::option::Option<&str> {
        self.email_address.as_deref()
    }
    /// <p>The contact's preference for being opted-in to or opted-out of a topic.&gt;</p>
    pub fn topic_preferences(&self) -> std::option::Option<&[crate::model::TopicPreference]> {
        self.topic_preferences.as_deref()
    }
    /// <p>The default topic preferences applied to the contact.</p>
    pub fn topic_default_preferences(
        &self,
    ) -> std::option::Option<&[crate::model::TopicPreference]> {
        self.topic_default_preferences.as_deref()
    }
    /// <p>A boolean value status noting if the contact is unsubscribed from all contact list topics.</p>
    pub fn unsubscribe_all(&self) -> bool {
        self.unsubscribe_all
    }
    /// <p>The attribute data attached to a contact.</p>
    pub fn attributes_data(&self) -> std::option::Option<&str> {
        self.attributes_data.as_deref()
    }
    /// <p>A timestamp noting when the contact was created.</p>
    pub fn created_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.created_timestamp.as_ref()
    }
    /// <p>A timestamp noting the last time the contact's information was updated.</p>
    pub fn last_updated_timestamp(&self) -> std::option::Option<&aws_smithy_types::DateTime> {
        self.last_updated_timestamp.as_ref()
    }
}
impl std::fmt::Debug for GetContactOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetContactOutput");
        formatter.field("contact_list_name", &self.contact_list_name);
        formatter.field("email_address", &self.email_address);
        formatter.field("topic_preferences", &self.topic_preferences);
        formatter.field("topic_default_preferences", &self.topic_default_preferences);
        formatter.field("unsubscribe_all", &self.unsubscribe_all);
        formatter.field("attributes_data", &self.attributes_data);
        formatter.field("created_timestamp", &self.created_timestamp);
        formatter.field("last_updated_timestamp", &self.last_updated_timestamp);
        formatter.finish()
    }
}
/// See [`GetContactOutput`](crate::output::GetContactOutput)
pub mod get_contact_output {
    /// A builder for [`GetContactOutput`](crate::output::GetContactOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) contact_list_name: std::option::Option<std::string::String>,
        pub(crate) email_address: std::option::Option<std::string::String>,
        pub(crate) topic_preferences:
            std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
        pub(crate) topic_default_preferences:
            std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
        pub(crate) unsubscribe_all: std::option::Option<bool>,
        pub(crate) attributes_data: std::option::Option<std::string::String>,
        pub(crate) created_timestamp: std::option::Option<aws_smithy_types::DateTime>,
        pub(crate) last_updated_timestamp: std::option::Option<aws_smithy_types::DateTime>,
    }
    impl Builder {
        /// <p>The name of the contact list to which the contact belongs.</p>
        pub fn contact_list_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.contact_list_name = Some(input.into());
            self
        }
        /// <p>The name of the contact list to which the contact belongs.</p>
        pub fn set_contact_list_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.contact_list_name = input;
            self
        }
        /// <p>The contact's email addres.</p>
        pub fn email_address(mut self, input: impl Into<std::string::String>) -> Self {
            self.email_address = Some(input.into());
            self
        }
        /// <p>The contact's email addres.</p>
        pub fn set_email_address(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.email_address = input;
            self
        }
        /// Appends an item to `topic_preferences`.
        ///
        /// To override the contents of this collection use [`set_topic_preferences`](Self::set_topic_preferences).
        ///
        /// <p>The contact's preference for being opted-in to or opted-out of a topic.&gt;</p>
        pub fn topic_preferences(mut self, input: crate::model::TopicPreference) -> Self {
            let mut v = self.topic_preferences.unwrap_or_default();
            v.push(input);
            self.topic_preferences = Some(v);
            self
        }
        /// <p>The contact's preference for being opted-in to or opted-out of a topic.&gt;</p>
        pub fn set_topic_preferences(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
        ) -> Self {
            self.topic_preferences = input;
            self
        }
        /// Appends an item to `topic_default_preferences`.
        ///
        /// To override the contents of this collection use [`set_topic_default_preferences`](Self::set_topic_default_preferences).
        ///
        /// <p>The default topic preferences applied to the contact.</p>
        pub fn topic_default_preferences(mut self, input: crate::model::TopicPreference) -> Self {
            let mut v = self.topic_default_preferences.unwrap_or_default();
            v.push(input);
            self.topic_default_preferences = Some(v);
            self
        }
        /// <p>The default topic preferences applied to the contact.</p>
        pub fn set_topic_default_preferences(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::TopicPreference>>,
        ) -> Self {
            self.topic_default_preferences = input;
            self
        }
        /// <p>A boolean value status noting if the contact is unsubscribed from all contact list topics.</p>
        pub fn unsubscribe_all(mut self, input: bool) -> Self {
            self.unsubscribe_all = Some(input);
            self
        }
        /// <p>A boolean value status noting if the contact is unsubscribed from all contact list topics.</p>
        pub fn set_unsubscribe_all(mut self, input: std::option::Option<bool>) -> Self {
            self.unsubscribe_all = input;
            self
        }
        /// <p>The attribute data attached to a contact.</p>
        pub fn attributes_data(mut self, input: impl Into<std::string::String>) -> Self {
            self.attributes_data = Some(input.into());
            self
        }
        /// <p>The attribute data attached to a contact.</p>
        pub fn set_attributes_data(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.attributes_data = input;
            self
        }
        /// <p>A timestamp noting when the contact was created.</p>
        pub fn created_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.created_timestamp = Some(input);
            self
        }
        /// <p>A timestamp noting when the contact was created.</p>
        pub fn set_created_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.created_timestamp = input;
            self
        }
        /// <p>A timestamp noting the last time the contact's information was updated.</p>
        pub fn last_updated_timestamp(mut self, input: aws_smithy_types::DateTime) -> Self {
            self.last_updated_timestamp = Some(input);
            self
        }
        /// <p>A timestamp noting the last time the contact's information was updated.</p>
        pub fn set_last_updated_timestamp(
            mut self,
            input: std::option::Option<aws_smithy_types::DateTime>,
        ) -> Self {
            self.last_updated_timestamp = input;
            self
        }
        /// Consumes the builder and constructs a [`GetContactOutput`](crate::output::GetContactOutput)
        pub fn build(self) -> crate::output::GetContactOutput {
            crate::output::GetContactOutput {
                contact_list_name: self.contact_list_name,
                email_address: self.email_address,
                topic_preferences: self.topic_preferences,
                topic_default_preferences: self.topic_default_preferences,
                unsubscribe_all: self.unsubscribe_all.unwrap_or_default(),
                attributes_data: self.attributes_data,
                created_timestamp: self.created_timestamp,
                last_updated_timestamp: self.last_updated_timestamp,
            }
        }
    }
}
impl GetContactOutput {
    /// Creates a new builder-style object to manufacture [`GetContactOutput`](crate::output::GetContactOutput)
    pub fn builder() -> crate::output::get_contact_output::Builder {
        crate::output::get_contact_output::Builder::default()
    }
}

/// <p>Information about an event destination for a configuration set.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConfigurationSetEventDestinationsOutput {
    /// <p>An array that includes all of the events destinations that have been configured for the configuration set.</p>
    pub event_destinations: std::option::Option<std::vec::Vec<crate::model::EventDestination>>,
}
impl GetConfigurationSetEventDestinationsOutput {
    /// <p>An array that includes all of the events destinations that have been configured for the configuration set.</p>
    pub fn event_destinations(&self) -> std::option::Option<&[crate::model::EventDestination]> {
        self.event_destinations.as_deref()
    }
}
impl std::fmt::Debug for GetConfigurationSetEventDestinationsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConfigurationSetEventDestinationsOutput");
        formatter.field("event_destinations", &self.event_destinations);
        formatter.finish()
    }
}
/// See [`GetConfigurationSetEventDestinationsOutput`](crate::output::GetConfigurationSetEventDestinationsOutput)
pub mod get_configuration_set_event_destinations_output {
    /// A builder for [`GetConfigurationSetEventDestinationsOutput`](crate::output::GetConfigurationSetEventDestinationsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) event_destinations:
            std::option::Option<std::vec::Vec<crate::model::EventDestination>>,
    }
    impl Builder {
        /// Appends an item to `event_destinations`.
        ///
        /// To override the contents of this collection use [`set_event_destinations`](Self::set_event_destinations).
        ///
        /// <p>An array that includes all of the events destinations that have been configured for the configuration set.</p>
        pub fn event_destinations(mut self, input: crate::model::EventDestination) -> Self {
            let mut v = self.event_destinations.unwrap_or_default();
            v.push(input);
            self.event_destinations = Some(v);
            self
        }
        /// <p>An array that includes all of the events destinations that have been configured for the configuration set.</p>
        pub fn set_event_destinations(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::EventDestination>>,
        ) -> Self {
            self.event_destinations = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConfigurationSetEventDestinationsOutput`](crate::output::GetConfigurationSetEventDestinationsOutput)
        pub fn build(self) -> crate::output::GetConfigurationSetEventDestinationsOutput {
            crate::output::GetConfigurationSetEventDestinationsOutput {
                event_destinations: self.event_destinations,
            }
        }
    }
}
impl GetConfigurationSetEventDestinationsOutput {
    /// Creates a new builder-style object to manufacture [`GetConfigurationSetEventDestinationsOutput`](crate::output::GetConfigurationSetEventDestinationsOutput)
    pub fn builder() -> crate::output::get_configuration_set_event_destinations_output::Builder {
        crate::output::get_configuration_set_event_destinations_output::Builder::default()
    }
}

/// <p>Information about a configuration set.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetConfigurationSetOutput {
    /// <p>The name of the configuration set.</p>
    pub configuration_set_name: std::option::Option<std::string::String>,
    /// <p>An object that defines the open and click tracking options for emails that you send using the configuration set.</p>
    pub tracking_options: std::option::Option<crate::model::TrackingOptions>,
    /// <p>An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.</p>
    pub delivery_options: std::option::Option<crate::model::DeliveryOptions>,
    /// <p>An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.</p>
    pub reputation_options: std::option::Option<crate::model::ReputationOptions>,
    /// <p>An object that defines whether or not Amazon SES can send email that you send using the configuration set.</p>
    pub sending_options: std::option::Option<crate::model::SendingOptions>,
    /// <p>An array of objects that define the tags (keys and values) that are associated with the configuration set.</p>
    pub tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
    /// <p>An object that contains information about the suppression list preferences for your account.</p>
    pub suppression_options: std::option::Option<crate::model::SuppressionOptions>,
}
impl GetConfigurationSetOutput {
    /// <p>The name of the configuration set.</p>
    pub fn configuration_set_name(&self) -> std::option::Option<&str> {
        self.configuration_set_name.as_deref()
    }
    /// <p>An object that defines the open and click tracking options for emails that you send using the configuration set.</p>
    pub fn tracking_options(&self) -> std::option::Option<&crate::model::TrackingOptions> {
        self.tracking_options.as_ref()
    }
    /// <p>An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.</p>
    pub fn delivery_options(&self) -> std::option::Option<&crate::model::DeliveryOptions> {
        self.delivery_options.as_ref()
    }
    /// <p>An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.</p>
    pub fn reputation_options(&self) -> std::option::Option<&crate::model::ReputationOptions> {
        self.reputation_options.as_ref()
    }
    /// <p>An object that defines whether or not Amazon SES can send email that you send using the configuration set.</p>
    pub fn sending_options(&self) -> std::option::Option<&crate::model::SendingOptions> {
        self.sending_options.as_ref()
    }
    /// <p>An array of objects that define the tags (keys and values) that are associated with the configuration set.</p>
    pub fn tags(&self) -> std::option::Option<&[crate::model::Tag]> {
        self.tags.as_deref()
    }
    /// <p>An object that contains information about the suppression list preferences for your account.</p>
    pub fn suppression_options(&self) -> std::option::Option<&crate::model::SuppressionOptions> {
        self.suppression_options.as_ref()
    }
}
impl std::fmt::Debug for GetConfigurationSetOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetConfigurationSetOutput");
        formatter.field("configuration_set_name", &self.configuration_set_name);
        formatter.field("tracking_options", &self.tracking_options);
        formatter.field("delivery_options", &self.delivery_options);
        formatter.field("reputation_options", &self.reputation_options);
        formatter.field("sending_options", &self.sending_options);
        formatter.field("tags", &self.tags);
        formatter.field("suppression_options", &self.suppression_options);
        formatter.finish()
    }
}
/// See [`GetConfigurationSetOutput`](crate::output::GetConfigurationSetOutput)
pub mod get_configuration_set_output {
    /// A builder for [`GetConfigurationSetOutput`](crate::output::GetConfigurationSetOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) configuration_set_name: std::option::Option<std::string::String>,
        pub(crate) tracking_options: std::option::Option<crate::model::TrackingOptions>,
        pub(crate) delivery_options: std::option::Option<crate::model::DeliveryOptions>,
        pub(crate) reputation_options: std::option::Option<crate::model::ReputationOptions>,
        pub(crate) sending_options: std::option::Option<crate::model::SendingOptions>,
        pub(crate) tags: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        pub(crate) suppression_options: std::option::Option<crate::model::SuppressionOptions>,
    }
    impl Builder {
        /// <p>The name of the configuration set.</p>
        pub fn configuration_set_name(mut self, input: impl Into<std::string::String>) -> Self {
            self.configuration_set_name = Some(input.into());
            self
        }
        /// <p>The name of the configuration set.</p>
        pub fn set_configuration_set_name(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.configuration_set_name = input;
            self
        }
        /// <p>An object that defines the open and click tracking options for emails that you send using the configuration set.</p>
        pub fn tracking_options(mut self, input: crate::model::TrackingOptions) -> Self {
            self.tracking_options = Some(input);
            self
        }
        /// <p>An object that defines the open and click tracking options for emails that you send using the configuration set.</p>
        pub fn set_tracking_options(
            mut self,
            input: std::option::Option<crate::model::TrackingOptions>,
        ) -> Self {
            self.tracking_options = input;
            self
        }
        /// <p>An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.</p>
        pub fn delivery_options(mut self, input: crate::model::DeliveryOptions) -> Self {
            self.delivery_options = Some(input);
            self
        }
        /// <p>An object that defines the dedicated IP pool that is used to send emails that you send using the configuration set.</p>
        pub fn set_delivery_options(
            mut self,
            input: std::option::Option<crate::model::DeliveryOptions>,
        ) -> Self {
            self.delivery_options = input;
            self
        }
        /// <p>An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.</p>
        pub fn reputation_options(mut self, input: crate::model::ReputationOptions) -> Self {
            self.reputation_options = Some(input);
            self
        }
        /// <p>An object that defines whether or not Amazon SES collects reputation metrics for the emails that you send that use the configuration set.</p>
        pub fn set_reputation_options(
            mut self,
            input: std::option::Option<crate::model::ReputationOptions>,
        ) -> Self {
            self.reputation_options = input;
            self
        }
        /// <p>An object that defines whether or not Amazon SES can send email that you send using the configuration set.</p>
        pub fn sending_options(mut self, input: crate::model::SendingOptions) -> Self {
            self.sending_options = Some(input);
            self
        }
        /// <p>An object that defines whether or not Amazon SES can send email that you send using the configuration set.</p>
        pub fn set_sending_options(
            mut self,
            input: std::option::Option<crate::model::SendingOptions>,
        ) -> Self {
            self.sending_options = input;
            self
        }
        /// Appends an item to `tags`.
        ///
        /// To override the contents of this collection use [`set_tags`](Self::set_tags).
        ///
        /// <p>An array of objects that define the tags (keys and values) that are associated with the configuration set.</p>
        pub fn tags(mut self, input: crate::model::Tag) -> Self {
            let mut v = self.tags.unwrap_or_default();
            v.push(input);
            self.tags = Some(v);
            self
        }
        /// <p>An array of objects that define the tags (keys and values) that are associated with the configuration set.</p>
        pub fn set_tags(
            mut self,
            input: std::option::Option<std::vec::Vec<crate::model::Tag>>,
        ) -> Self {
            self.tags = input;
            self
        }
        /// <p>An object that contains information about the suppression list preferences for your account.</p>
        pub fn suppression_options(mut self, input: crate::model::SuppressionOptions) -> Self {
            self.suppression_options = Some(input);
            self
        }
        /// <p>An object that contains information about the suppression list preferences for your account.</p>
        pub fn set_suppression_options(
            mut self,
            input: std::option::Option<crate::model::SuppressionOptions>,
        ) -> Self {
            self.suppression_options = input;
            self
        }
        /// Consumes the builder and constructs a [`GetConfigurationSetOutput`](crate::output::GetConfigurationSetOutput)
        pub fn build(self) -> crate::output::GetConfigurationSetOutput {
            crate::output::GetConfigurationSetOutput {
                configuration_set_name: self.configuration_set_name,
                tracking_options: self.tracking_options,
                delivery_options: self.delivery_options,
                reputation_options: self.reputation_options,
                sending_options: self.sending_options,
                tags: self.tags,
                suppression_options: self.suppression_options,
            }
        }
    }
}
impl GetConfigurationSetOutput {
    /// Creates a new builder-style object to manufacture [`GetConfigurationSetOutput`](crate::output::GetConfigurationSetOutput)
    pub fn builder() -> crate::output::get_configuration_set_output::Builder {
        crate::output::get_configuration_set_output::Builder::default()
    }
}

/// <p>An object that contains information about blacklist events.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetBlacklistReportsOutput {
    /// <p>An object that contains information about a blacklist that one of your dedicated IP addresses appears on.</p>
    pub blacklist_report: std::option::Option<
        std::collections::HashMap<std::string::String, std::vec::Vec<crate::model::BlacklistEntry>>,
    >,
}
impl GetBlacklistReportsOutput {
    /// <p>An object that contains information about a blacklist that one of your dedicated IP addresses appears on.</p>
    pub fn blacklist_report(
        &self,
    ) -> std::option::Option<
        &std::collections::HashMap<
            std::string::String,
            std::vec::Vec<crate::model::BlacklistEntry>,
        >,
    > {
        self.blacklist_report.as_ref()
    }
}
impl std::fmt::Debug for GetBlacklistReportsOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetBlacklistReportsOutput");
        formatter.field("blacklist_report", &self.blacklist_report);
        formatter.finish()
    }
}
/// See [`GetBlacklistReportsOutput`](crate::output::GetBlacklistReportsOutput)
pub mod get_blacklist_reports_output {
    /// A builder for [`GetBlacklistReportsOutput`](crate::output::GetBlacklistReportsOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) blacklist_report: std::option::Option<
            std::collections::HashMap<
                std::string::String,
                std::vec::Vec<crate::model::BlacklistEntry>,
            >,
        >,
    }
    impl Builder {
        /// Adds a key-value pair to `blacklist_report`.
        ///
        /// To override the contents of this collection use [`set_blacklist_report`](Self::set_blacklist_report).
        ///
        /// <p>An object that contains information about a blacklist that one of your dedicated IP addresses appears on.</p>
        pub fn blacklist_report(
            mut self,
            k: impl Into<std::string::String>,
            v: std::vec::Vec<crate::model::BlacklistEntry>,
        ) -> Self {
            let mut hash_map = self.blacklist_report.unwrap_or_default();
            hash_map.insert(k.into(), v);
            self.blacklist_report = Some(hash_map);
            self
        }
        /// <p>An object that contains information about a blacklist that one of your dedicated IP addresses appears on.</p>
        pub fn set_blacklist_report(
            mut self,
            input: std::option::Option<
                std::collections::HashMap<
                    std::string::String,
                    std::vec::Vec<crate::model::BlacklistEntry>,
                >,
            >,
        ) -> Self {
            self.blacklist_report = input;
            self
        }
        /// Consumes the builder and constructs a [`GetBlacklistReportsOutput`](crate::output::GetBlacklistReportsOutput)
        pub fn build(self) -> crate::output::GetBlacklistReportsOutput {
            crate::output::GetBlacklistReportsOutput {
                blacklist_report: self.blacklist_report,
            }
        }
    }
}
impl GetBlacklistReportsOutput {
    /// Creates a new builder-style object to manufacture [`GetBlacklistReportsOutput`](crate::output::GetBlacklistReportsOutput)
    pub fn builder() -> crate::output::get_blacklist_reports_output::Builder {
        crate::output::get_blacklist_reports_output::Builder::default()
    }
}

/// <p>A list of details about the email-sending capabilities of your Amazon SES account in the current Amazon Web Services Region.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct GetAccountOutput {
    /// <p>Indicates whether or not the automatic warm-up feature is enabled for dedicated IP addresses that are associated with your account.</p>
    pub dedicated_ip_auto_warmup_enabled: bool,
    /// <p>The reputation status of your Amazon SES account. The status can be one of the following:</p>
    /// <ul>
    /// <li> <p> <code>HEALTHY</code> – There are no reputation-related issues that currently impact your account.</p> </li>
    /// <li> <p> <code>PROBATION</code> – We've identified potential issues with your Amazon SES account. We're placing your account under review while you work on correcting these issues.</p> </li>
    /// <li> <p> <code>SHUTDOWN</code> – Your account's ability to send email is currently paused because of an issue with the email sent from your account. When you correct the issue, you can contact us and request that your account's ability to send email is resumed.</p> </li>
    /// </ul>
    pub enforcement_status: std::option::Option<std::string::String>,
    /// <p>Indicates whether or not your account has production access in the current Amazon Web Services Region.</p>
    /// <p>If the value is <code>false</code>, then your account is in the <i>sandbox</i>. When your account is in the sandbox, you can only send email to verified identities. Additionally, the maximum number of emails you can send in a 24-hour period (your sending quota) is 200, and the maximum number of emails you can send per second (your maximum sending rate) is 1.</p>
    /// <p>If the value is <code>true</code>, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.</p>
    pub production_access_enabled: bool,
    /// <p>An object that contains information about the per-day and per-second sending limits for your Amazon SES account in the current Amazon Web Services Region.</p>
    pub send_quota: std::option::Option<crate::model::SendQuota>,
    /// <p>Indicates whether or not email sending is enabled for your Amazon SES account in the current Amazon Web Services Region.</p>
    pub sending_enabled: bool,
    /// <p>An object that contains information about the email address suppression preferences for your account in the current Amazon Web Services Region.</p>
    pub suppression_attributes: std::option::Option<crate::model::SuppressionAttributes>,
    /// <p>An object that defines your account details.</p>
    pub details: std::option::Option<crate::model::AccountDetails>,
}
impl GetAccountOutput {
    /// <p>Indicates whether or not the automatic warm-up feature is enabled for dedicated IP addresses that are associated with your account.</p>
    pub fn dedicated_ip_auto_warmup_enabled(&self) -> bool {
        self.dedicated_ip_auto_warmup_enabled
    }
    /// <p>The reputation status of your Amazon SES account. The status can be one of the following:</p>
    /// <ul>
    /// <li> <p> <code>HEALTHY</code> – There are no reputation-related issues that currently impact your account.</p> </li>
    /// <li> <p> <code>PROBATION</code> – We've identified potential issues with your Amazon SES account. We're placing your account under review while you work on correcting these issues.</p> </li>
    /// <li> <p> <code>SHUTDOWN</code> – Your account's ability to send email is currently paused because of an issue with the email sent from your account. When you correct the issue, you can contact us and request that your account's ability to send email is resumed.</p> </li>
    /// </ul>
    pub fn enforcement_status(&self) -> std::option::Option<&str> {
        self.enforcement_status.as_deref()
    }
    /// <p>Indicates whether or not your account has production access in the current Amazon Web Services Region.</p>
    /// <p>If the value is <code>false</code>, then your account is in the <i>sandbox</i>. When your account is in the sandbox, you can only send email to verified identities. Additionally, the maximum number of emails you can send in a 24-hour period (your sending quota) is 200, and the maximum number of emails you can send per second (your maximum sending rate) is 1.</p>
    /// <p>If the value is <code>true</code>, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.</p>
    pub fn production_access_enabled(&self) -> bool {
        self.production_access_enabled
    }
    /// <p>An object that contains information about the per-day and per-second sending limits for your Amazon SES account in the current Amazon Web Services Region.</p>
    pub fn send_quota(&self) -> std::option::Option<&crate::model::SendQuota> {
        self.send_quota.as_ref()
    }
    /// <p>Indicates whether or not email sending is enabled for your Amazon SES account in the current Amazon Web Services Region.</p>
    pub fn sending_enabled(&self) -> bool {
        self.sending_enabled
    }
    /// <p>An object that contains information about the email address suppression preferences for your account in the current Amazon Web Services Region.</p>
    pub fn suppression_attributes(
        &self,
    ) -> std::option::Option<&crate::model::SuppressionAttributes> {
        self.suppression_attributes.as_ref()
    }
    /// <p>An object that defines your account details.</p>
    pub fn details(&self) -> std::option::Option<&crate::model::AccountDetails> {
        self.details.as_ref()
    }
}
impl std::fmt::Debug for GetAccountOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("GetAccountOutput");
        formatter.field(
            "dedicated_ip_auto_warmup_enabled",
            &self.dedicated_ip_auto_warmup_enabled,
        );
        formatter.field("enforcement_status", &self.enforcement_status);
        formatter.field("production_access_enabled", &self.production_access_enabled);
        formatter.field("send_quota", &self.send_quota);
        formatter.field("sending_enabled", &self.sending_enabled);
        formatter.field("suppression_attributes", &self.suppression_attributes);
        formatter.field("details", &self.details);
        formatter.finish()
    }
}
/// See [`GetAccountOutput`](crate::output::GetAccountOutput)
pub mod get_account_output {
    /// A builder for [`GetAccountOutput`](crate::output::GetAccountOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) dedicated_ip_auto_warmup_enabled: std::option::Option<bool>,
        pub(crate) enforcement_status: std::option::Option<std::string::String>,
        pub(crate) production_access_enabled: std::option::Option<bool>,
        pub(crate) send_quota: std::option::Option<crate::model::SendQuota>,
        pub(crate) sending_enabled: std::option::Option<bool>,
        pub(crate) suppression_attributes: std::option::Option<crate::model::SuppressionAttributes>,
        pub(crate) details: std::option::Option<crate::model::AccountDetails>,
    }
    impl Builder {
        /// <p>Indicates whether or not the automatic warm-up feature is enabled for dedicated IP addresses that are associated with your account.</p>
        pub fn dedicated_ip_auto_warmup_enabled(mut self, input: bool) -> Self {
            self.dedicated_ip_auto_warmup_enabled = Some(input);
            self
        }
        /// <p>Indicates whether or not the automatic warm-up feature is enabled for dedicated IP addresses that are associated with your account.</p>
        pub fn set_dedicated_ip_auto_warmup_enabled(
            mut self,
            input: std::option::Option<bool>,
        ) -> Self {
            self.dedicated_ip_auto_warmup_enabled = input;
            self
        }
        /// <p>The reputation status of your Amazon SES account. The status can be one of the following:</p>
        /// <ul>
        /// <li> <p> <code>HEALTHY</code> – There are no reputation-related issues that currently impact your account.</p> </li>
        /// <li> <p> <code>PROBATION</code> – We've identified potential issues with your Amazon SES account. We're placing your account under review while you work on correcting these issues.</p> </li>
        /// <li> <p> <code>SHUTDOWN</code> – Your account's ability to send email is currently paused because of an issue with the email sent from your account. When you correct the issue, you can contact us and request that your account's ability to send email is resumed.</p> </li>
        /// </ul>
        pub fn enforcement_status(mut self, input: impl Into<std::string::String>) -> Self {
            self.enforcement_status = Some(input.into());
            self
        }
        /// <p>The reputation status of your Amazon SES account. The status can be one of the following:</p>
        /// <ul>
        /// <li> <p> <code>HEALTHY</code> – There are no reputation-related issues that currently impact your account.</p> </li>
        /// <li> <p> <code>PROBATION</code> – We've identified potential issues with your Amazon SES account. We're placing your account under review while you work on correcting these issues.</p> </li>
        /// <li> <p> <code>SHUTDOWN</code> – Your account's ability to send email is currently paused because of an issue with the email sent from your account. When you correct the issue, you can contact us and request that your account's ability to send email is resumed.</p> </li>
        /// </ul>
        pub fn set_enforcement_status(
            mut self,
            input: std::option::Option<std::string::String>,
        ) -> Self {
            self.enforcement_status = input;
            self
        }
        /// <p>Indicates whether or not your account has production access in the current Amazon Web Services Region.</p>
        /// <p>If the value is <code>false</code>, then your account is in the <i>sandbox</i>. When your account is in the sandbox, you can only send email to verified identities. Additionally, the maximum number of emails you can send in a 24-hour period (your sending quota) is 200, and the maximum number of emails you can send per second (your maximum sending rate) is 1.</p>
        /// <p>If the value is <code>true</code>, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.</p>
        pub fn production_access_enabled(mut self, input: bool) -> Self {
            self.production_access_enabled = Some(input);
            self
        }
        /// <p>Indicates whether or not your account has production access in the current Amazon Web Services Region.</p>
        /// <p>If the value is <code>false</code>, then your account is in the <i>sandbox</i>. When your account is in the sandbox, you can only send email to verified identities. Additionally, the maximum number of emails you can send in a 24-hour period (your sending quota) is 200, and the maximum number of emails you can send per second (your maximum sending rate) is 1.</p>
        /// <p>If the value is <code>true</code>, then your account has production access. When your account has production access, you can send email to any address. The sending quota and maximum sending rate for your account vary based on your specific use case.</p>
        pub fn set_production_access_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.production_access_enabled = input;
            self
        }
        /// <p>An object that contains information about the per-day and per-second sending limits for your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn send_quota(mut self, input: crate::model::SendQuota) -> Self {
            self.send_quota = Some(input);
            self
        }
        /// <p>An object that contains information about the per-day and per-second sending limits for your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn set_send_quota(
            mut self,
            input: std::option::Option<crate::model::SendQuota>,
        ) -> Self {
            self.send_quota = input;
            self
        }
        /// <p>Indicates whether or not email sending is enabled for your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn sending_enabled(mut self, input: bool) -> Self {
            self.sending_enabled = Some(input);
            self
        }
        /// <p>Indicates whether or not email sending is enabled for your Amazon SES account in the current Amazon Web Services Region.</p>
        pub fn set_sending_enabled(mut self, input: std::option::Option<bool>) -> Self {
            self.sending_enabled = input;
            self
        }
        /// <p>An object that contains information about the email address suppression preferences for your account in the current Amazon Web Services Region.</p>
        pub fn suppression_attributes(
            mut self,
            input: crate::model::SuppressionAttributes,
        ) -> Self {
            self.suppression_attributes = Some(input);
            self
        }
        /// <p>An object that contains information about the email address suppression preferences for your account in the current Amazon Web Services Region.</p>
        pub fn set_suppression_attributes(
            mut self,
            input: std::option::Option<crate::model::SuppressionAttributes>,
        ) -> Self {
            self.suppression_attributes = input;
            self
        }
        /// <p>An object that defines your account details.</p>
        pub fn details(mut self, input: crate::model::AccountDetails) -> Self {
            self.details = Some(input);
            self
        }
        /// <p>An object that defines your account details.</p>
        pub fn set_details(
            mut self,
            input: std::option::Option<crate::model::AccountDetails>,
        ) -> Self {
            self.details = input;
            self
        }
        /// Consumes the builder and constructs a [`GetAccountOutput`](crate::output::GetAccountOutput)
        pub fn build(self) -> crate::output::GetAccountOutput {
            crate::output::GetAccountOutput {
                dedicated_ip_auto_warmup_enabled: self
                    .dedicated_ip_auto_warmup_enabled
                    .unwrap_or_default(),
                enforcement_status: self.enforcement_status,
                production_access_enabled: self.production_access_enabled.unwrap_or_default(),
                send_quota: self.send_quota,
                sending_enabled: self.sending_enabled.unwrap_or_default(),
                suppression_attributes: self.suppression_attributes,
                details: self.details,
            }
        }
    }
}
impl GetAccountOutput {
    /// Creates a new builder-style object to manufacture [`GetAccountOutput`](crate::output::GetAccountOutput)
    pub fn builder() -> crate::output::get_account_output::Builder {
        crate::output::get_account_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteSuppressedDestinationOutput {}
impl std::fmt::Debug for DeleteSuppressedDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteSuppressedDestinationOutput");
        formatter.finish()
    }
}
/// See [`DeleteSuppressedDestinationOutput`](crate::output::DeleteSuppressedDestinationOutput)
pub mod delete_suppressed_destination_output {
    /// A builder for [`DeleteSuppressedDestinationOutput`](crate::output::DeleteSuppressedDestinationOutput)
    #[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 [`DeleteSuppressedDestinationOutput`](crate::output::DeleteSuppressedDestinationOutput)
        pub fn build(self) -> crate::output::DeleteSuppressedDestinationOutput {
            crate::output::DeleteSuppressedDestinationOutput {}
        }
    }
}
impl DeleteSuppressedDestinationOutput {
    /// Creates a new builder-style object to manufacture [`DeleteSuppressedDestinationOutput`](crate::output::DeleteSuppressedDestinationOutput)
    pub fn builder() -> crate::output::delete_suppressed_destination_output::Builder {
        crate::output::delete_suppressed_destination_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteEmailTemplateOutput {}
impl std::fmt::Debug for DeleteEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`DeleteEmailTemplateOutput`](crate::output::DeleteEmailTemplateOutput)
pub mod delete_email_template_output {
    /// A builder for [`DeleteEmailTemplateOutput`](crate::output::DeleteEmailTemplateOutput)
    #[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 [`DeleteEmailTemplateOutput`](crate::output::DeleteEmailTemplateOutput)
        pub fn build(self) -> crate::output::DeleteEmailTemplateOutput {
            crate::output::DeleteEmailTemplateOutput {}
        }
    }
}
impl DeleteEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEmailTemplateOutput`](crate::output::DeleteEmailTemplateOutput)
    pub fn builder() -> crate::output::delete_email_template_output::Builder {
        crate::output::delete_email_template_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteEmailIdentityPolicyOutput {}
impl std::fmt::Debug for DeleteEmailIdentityPolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteEmailIdentityPolicyOutput");
        formatter.finish()
    }
}
/// See [`DeleteEmailIdentityPolicyOutput`](crate::output::DeleteEmailIdentityPolicyOutput)
pub mod delete_email_identity_policy_output {
    /// A builder for [`DeleteEmailIdentityPolicyOutput`](crate::output::DeleteEmailIdentityPolicyOutput)
    #[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 [`DeleteEmailIdentityPolicyOutput`](crate::output::DeleteEmailIdentityPolicyOutput)
        pub fn build(self) -> crate::output::DeleteEmailIdentityPolicyOutput {
            crate::output::DeleteEmailIdentityPolicyOutput {}
        }
    }
}
impl DeleteEmailIdentityPolicyOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEmailIdentityPolicyOutput`](crate::output::DeleteEmailIdentityPolicyOutput)
    pub fn builder() -> crate::output::delete_email_identity_policy_output::Builder {
        crate::output::delete_email_identity_policy_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteEmailIdentityOutput {}
impl std::fmt::Debug for DeleteEmailIdentityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteEmailIdentityOutput");
        formatter.finish()
    }
}
/// See [`DeleteEmailIdentityOutput`](crate::output::DeleteEmailIdentityOutput)
pub mod delete_email_identity_output {
    /// A builder for [`DeleteEmailIdentityOutput`](crate::output::DeleteEmailIdentityOutput)
    #[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 [`DeleteEmailIdentityOutput`](crate::output::DeleteEmailIdentityOutput)
        pub fn build(self) -> crate::output::DeleteEmailIdentityOutput {
            crate::output::DeleteEmailIdentityOutput {}
        }
    }
}
impl DeleteEmailIdentityOutput {
    /// Creates a new builder-style object to manufacture [`DeleteEmailIdentityOutput`](crate::output::DeleteEmailIdentityOutput)
    pub fn builder() -> crate::output::delete_email_identity_output::Builder {
        crate::output::delete_email_identity_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteDedicatedIpPoolOutput {}
impl std::fmt::Debug for DeleteDedicatedIpPoolOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteDedicatedIpPoolOutput");
        formatter.finish()
    }
}
/// See [`DeleteDedicatedIpPoolOutput`](crate::output::DeleteDedicatedIpPoolOutput)
pub mod delete_dedicated_ip_pool_output {
    /// A builder for [`DeleteDedicatedIpPoolOutput`](crate::output::DeleteDedicatedIpPoolOutput)
    #[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 [`DeleteDedicatedIpPoolOutput`](crate::output::DeleteDedicatedIpPoolOutput)
        pub fn build(self) -> crate::output::DeleteDedicatedIpPoolOutput {
            crate::output::DeleteDedicatedIpPoolOutput {}
        }
    }
}
impl DeleteDedicatedIpPoolOutput {
    /// Creates a new builder-style object to manufacture [`DeleteDedicatedIpPoolOutput`](crate::output::DeleteDedicatedIpPoolOutput)
    pub fn builder() -> crate::output::delete_dedicated_ip_pool_output::Builder {
        crate::output::delete_dedicated_ip_pool_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteCustomVerificationEmailTemplateOutput {}
impl std::fmt::Debug for DeleteCustomVerificationEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteCustomVerificationEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`DeleteCustomVerificationEmailTemplateOutput`](crate::output::DeleteCustomVerificationEmailTemplateOutput)
pub mod delete_custom_verification_email_template_output {
    /// A builder for [`DeleteCustomVerificationEmailTemplateOutput`](crate::output::DeleteCustomVerificationEmailTemplateOutput)
    #[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 [`DeleteCustomVerificationEmailTemplateOutput`](crate::output::DeleteCustomVerificationEmailTemplateOutput)
        pub fn build(self) -> crate::output::DeleteCustomVerificationEmailTemplateOutput {
            crate::output::DeleteCustomVerificationEmailTemplateOutput {}
        }
    }
}
impl DeleteCustomVerificationEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`DeleteCustomVerificationEmailTemplateOutput`](crate::output::DeleteCustomVerificationEmailTemplateOutput)
    pub fn builder() -> crate::output::delete_custom_verification_email_template_output::Builder {
        crate::output::delete_custom_verification_email_template_output::Builder::default()
    }
}

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

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

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConfigurationSetEventDestinationOutput {}
impl std::fmt::Debug for DeleteConfigurationSetEventDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConfigurationSetEventDestinationOutput");
        formatter.finish()
    }
}
/// See [`DeleteConfigurationSetEventDestinationOutput`](crate::output::DeleteConfigurationSetEventDestinationOutput)
pub mod delete_configuration_set_event_destination_output {
    /// A builder for [`DeleteConfigurationSetEventDestinationOutput`](crate::output::DeleteConfigurationSetEventDestinationOutput)
    #[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 [`DeleteConfigurationSetEventDestinationOutput`](crate::output::DeleteConfigurationSetEventDestinationOutput)
        pub fn build(self) -> crate::output::DeleteConfigurationSetEventDestinationOutput {
            crate::output::DeleteConfigurationSetEventDestinationOutput {}
        }
    }
}
impl DeleteConfigurationSetEventDestinationOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConfigurationSetEventDestinationOutput`](crate::output::DeleteConfigurationSetEventDestinationOutput)
    pub fn builder() -> crate::output::delete_configuration_set_event_destination_output::Builder {
        crate::output::delete_configuration_set_event_destination_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct DeleteConfigurationSetOutput {}
impl std::fmt::Debug for DeleteConfigurationSetOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("DeleteConfigurationSetOutput");
        formatter.finish()
    }
}
/// See [`DeleteConfigurationSetOutput`](crate::output::DeleteConfigurationSetOutput)
pub mod delete_configuration_set_output {
    /// A builder for [`DeleteConfigurationSetOutput`](crate::output::DeleteConfigurationSetOutput)
    #[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 [`DeleteConfigurationSetOutput`](crate::output::DeleteConfigurationSetOutput)
        pub fn build(self) -> crate::output::DeleteConfigurationSetOutput {
            crate::output::DeleteConfigurationSetOutput {}
        }
    }
}
impl DeleteConfigurationSetOutput {
    /// Creates a new builder-style object to manufacture [`DeleteConfigurationSetOutput`](crate::output::DeleteConfigurationSetOutput)
    pub fn builder() -> crate::output::delete_configuration_set_output::Builder {
        crate::output::delete_configuration_set_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateImportJobOutput {
    /// <p>A string that represents the import job ID.</p>
    pub job_id: std::option::Option<std::string::String>,
}
impl CreateImportJobOutput {
    /// <p>A string that represents the import job ID.</p>
    pub fn job_id(&self) -> std::option::Option<&str> {
        self.job_id.as_deref()
    }
}
impl std::fmt::Debug for CreateImportJobOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateImportJobOutput");
        formatter.field("job_id", &self.job_id);
        formatter.finish()
    }
}
/// See [`CreateImportJobOutput`](crate::output::CreateImportJobOutput)
pub mod create_import_job_output {
    /// A builder for [`CreateImportJobOutput`](crate::output::CreateImportJobOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) job_id: std::option::Option<std::string::String>,
    }
    impl Builder {
        /// <p>A string that represents the import job ID.</p>
        pub fn job_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.job_id = Some(input.into());
            self
        }
        /// <p>A string that represents the import job ID.</p>
        pub fn set_job_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.job_id = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateImportJobOutput`](crate::output::CreateImportJobOutput)
        pub fn build(self) -> crate::output::CreateImportJobOutput {
            crate::output::CreateImportJobOutput {
                job_id: self.job_id,
            }
        }
    }
}
impl CreateImportJobOutput {
    /// Creates a new builder-style object to manufacture [`CreateImportJobOutput`](crate::output::CreateImportJobOutput)
    pub fn builder() -> crate::output::create_import_job_output::Builder {
        crate::output::create_import_job_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateEmailTemplateOutput {}
impl std::fmt::Debug for CreateEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`CreateEmailTemplateOutput`](crate::output::CreateEmailTemplateOutput)
pub mod create_email_template_output {
    /// A builder for [`CreateEmailTemplateOutput`](crate::output::CreateEmailTemplateOutput)
    #[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 [`CreateEmailTemplateOutput`](crate::output::CreateEmailTemplateOutput)
        pub fn build(self) -> crate::output::CreateEmailTemplateOutput {
            crate::output::CreateEmailTemplateOutput {}
        }
    }
}
impl CreateEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`CreateEmailTemplateOutput`](crate::output::CreateEmailTemplateOutput)
    pub fn builder() -> crate::output::create_email_template_output::Builder {
        crate::output::create_email_template_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateEmailIdentityPolicyOutput {}
impl std::fmt::Debug for CreateEmailIdentityPolicyOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateEmailIdentityPolicyOutput");
        formatter.finish()
    }
}
/// See [`CreateEmailIdentityPolicyOutput`](crate::output::CreateEmailIdentityPolicyOutput)
pub mod create_email_identity_policy_output {
    /// A builder for [`CreateEmailIdentityPolicyOutput`](crate::output::CreateEmailIdentityPolicyOutput)
    #[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 [`CreateEmailIdentityPolicyOutput`](crate::output::CreateEmailIdentityPolicyOutput)
        pub fn build(self) -> crate::output::CreateEmailIdentityPolicyOutput {
            crate::output::CreateEmailIdentityPolicyOutput {}
        }
    }
}
impl CreateEmailIdentityPolicyOutput {
    /// Creates a new builder-style object to manufacture [`CreateEmailIdentityPolicyOutput`](crate::output::CreateEmailIdentityPolicyOutput)
    pub fn builder() -> crate::output::create_email_identity_policy_output::Builder {
        crate::output::create_email_identity_policy_output::Builder::default()
    }
}

/// <p>If the email identity is a domain, this object contains information about the DKIM verification status for the domain.</p>
/// <p>If the email identity is an email address, this object is empty. </p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateEmailIdentityOutput {
    /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
    pub identity_type: std::option::Option<crate::model::IdentityType>,
    /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
    pub verified_for_sending_status: bool,
    /// <p>An object that contains information about the DKIM attributes for the identity.</p>
    pub dkim_attributes: std::option::Option<crate::model::DkimAttributes>,
}
impl CreateEmailIdentityOutput {
    /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
    pub fn identity_type(&self) -> std::option::Option<&crate::model::IdentityType> {
        self.identity_type.as_ref()
    }
    /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
    pub fn verified_for_sending_status(&self) -> bool {
        self.verified_for_sending_status
    }
    /// <p>An object that contains information about the DKIM attributes for the identity.</p>
    pub fn dkim_attributes(&self) -> std::option::Option<&crate::model::DkimAttributes> {
        self.dkim_attributes.as_ref()
    }
}
impl std::fmt::Debug for CreateEmailIdentityOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateEmailIdentityOutput");
        formatter.field("identity_type", &self.identity_type);
        formatter.field(
            "verified_for_sending_status",
            &self.verified_for_sending_status,
        );
        formatter.field("dkim_attributes", &self.dkim_attributes);
        formatter.finish()
    }
}
/// See [`CreateEmailIdentityOutput`](crate::output::CreateEmailIdentityOutput)
pub mod create_email_identity_output {
    /// A builder for [`CreateEmailIdentityOutput`](crate::output::CreateEmailIdentityOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) identity_type: std::option::Option<crate::model::IdentityType>,
        pub(crate) verified_for_sending_status: std::option::Option<bool>,
        pub(crate) dkim_attributes: std::option::Option<crate::model::DkimAttributes>,
    }
    impl Builder {
        /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
        pub fn identity_type(mut self, input: crate::model::IdentityType) -> Self {
            self.identity_type = Some(input);
            self
        }
        /// <p>The email identity type. Note: the <code>MANAGED_DOMAIN</code> identity type is not supported.</p>
        pub fn set_identity_type(
            mut self,
            input: std::option::Option<crate::model::IdentityType>,
        ) -> Self {
            self.identity_type = input;
            self
        }
        /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
        pub fn verified_for_sending_status(mut self, input: bool) -> Self {
            self.verified_for_sending_status = Some(input);
            self
        }
        /// <p>Specifies whether or not the identity is verified. You can only send email from verified email addresses or domains. For more information about verifying identities, see the <a href="https://docs.aws.amazon.com/pinpoint/latest/userguide/channels-email-manage-verify.html">Amazon Pinpoint User Guide</a>.</p>
        pub fn set_verified_for_sending_status(mut self, input: std::option::Option<bool>) -> Self {
            self.verified_for_sending_status = input;
            self
        }
        /// <p>An object that contains information about the DKIM attributes for the identity.</p>
        pub fn dkim_attributes(mut self, input: crate::model::DkimAttributes) -> Self {
            self.dkim_attributes = Some(input);
            self
        }
        /// <p>An object that contains information about the DKIM attributes for the identity.</p>
        pub fn set_dkim_attributes(
            mut self,
            input: std::option::Option<crate::model::DkimAttributes>,
        ) -> Self {
            self.dkim_attributes = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateEmailIdentityOutput`](crate::output::CreateEmailIdentityOutput)
        pub fn build(self) -> crate::output::CreateEmailIdentityOutput {
            crate::output::CreateEmailIdentityOutput {
                identity_type: self.identity_type,
                verified_for_sending_status: self.verified_for_sending_status.unwrap_or_default(),
                dkim_attributes: self.dkim_attributes,
            }
        }
    }
}
impl CreateEmailIdentityOutput {
    /// Creates a new builder-style object to manufacture [`CreateEmailIdentityOutput`](crate::output::CreateEmailIdentityOutput)
    pub fn builder() -> crate::output::create_email_identity_output::Builder {
        crate::output::create_email_identity_output::Builder::default()
    }
}

/// <p>Information about the predictive inbox placement test that you created.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDeliverabilityTestReportOutput {
    /// <p>A unique string that identifies the predictive inbox placement test.</p>
    pub report_id: std::option::Option<std::string::String>,
    /// <p>The status of the predictive inbox placement test. If the status is <code>IN_PROGRESS</code>, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is <code>COMPLETE</code>, then the test is finished, and you can use the <code>GetDeliverabilityTestReport</code> to view the results of the test.</p>
    pub deliverability_test_status: std::option::Option<crate::model::DeliverabilityTestStatus>,
}
impl CreateDeliverabilityTestReportOutput {
    /// <p>A unique string that identifies the predictive inbox placement test.</p>
    pub fn report_id(&self) -> std::option::Option<&str> {
        self.report_id.as_deref()
    }
    /// <p>The status of the predictive inbox placement test. If the status is <code>IN_PROGRESS</code>, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is <code>COMPLETE</code>, then the test is finished, and you can use the <code>GetDeliverabilityTestReport</code> to view the results of the test.</p>
    pub fn deliverability_test_status(
        &self,
    ) -> std::option::Option<&crate::model::DeliverabilityTestStatus> {
        self.deliverability_test_status.as_ref()
    }
}
impl std::fmt::Debug for CreateDeliverabilityTestReportOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDeliverabilityTestReportOutput");
        formatter.field("report_id", &self.report_id);
        formatter.field(
            "deliverability_test_status",
            &self.deliverability_test_status,
        );
        formatter.finish()
    }
}
/// See [`CreateDeliverabilityTestReportOutput`](crate::output::CreateDeliverabilityTestReportOutput)
pub mod create_deliverability_test_report_output {
    /// A builder for [`CreateDeliverabilityTestReportOutput`](crate::output::CreateDeliverabilityTestReportOutput)
    #[non_exhaustive]
    #[derive(std::default::Default, std::clone::Clone, std::cmp::PartialEq, std::fmt::Debug)]
    pub struct Builder {
        pub(crate) report_id: std::option::Option<std::string::String>,
        pub(crate) deliverability_test_status:
            std::option::Option<crate::model::DeliverabilityTestStatus>,
    }
    impl Builder {
        /// <p>A unique string that identifies the predictive inbox placement test.</p>
        pub fn report_id(mut self, input: impl Into<std::string::String>) -> Self {
            self.report_id = Some(input.into());
            self
        }
        /// <p>A unique string that identifies the predictive inbox placement test.</p>
        pub fn set_report_id(mut self, input: std::option::Option<std::string::String>) -> Self {
            self.report_id = input;
            self
        }
        /// <p>The status of the predictive inbox placement test. If the status is <code>IN_PROGRESS</code>, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is <code>COMPLETE</code>, then the test is finished, and you can use the <code>GetDeliverabilityTestReport</code> to view the results of the test.</p>
        pub fn deliverability_test_status(
            mut self,
            input: crate::model::DeliverabilityTestStatus,
        ) -> Self {
            self.deliverability_test_status = Some(input);
            self
        }
        /// <p>The status of the predictive inbox placement test. If the status is <code>IN_PROGRESS</code>, then the predictive inbox placement test is currently running. Predictive inbox placement tests are usually complete within 24 hours of creating the test. If the status is <code>COMPLETE</code>, then the test is finished, and you can use the <code>GetDeliverabilityTestReport</code> to view the results of the test.</p>
        pub fn set_deliverability_test_status(
            mut self,
            input: std::option::Option<crate::model::DeliverabilityTestStatus>,
        ) -> Self {
            self.deliverability_test_status = input;
            self
        }
        /// Consumes the builder and constructs a [`CreateDeliverabilityTestReportOutput`](crate::output::CreateDeliverabilityTestReportOutput)
        pub fn build(self) -> crate::output::CreateDeliverabilityTestReportOutput {
            crate::output::CreateDeliverabilityTestReportOutput {
                report_id: self.report_id,
                deliverability_test_status: self.deliverability_test_status,
            }
        }
    }
}
impl CreateDeliverabilityTestReportOutput {
    /// Creates a new builder-style object to manufacture [`CreateDeliverabilityTestReportOutput`](crate::output::CreateDeliverabilityTestReportOutput)
    pub fn builder() -> crate::output::create_deliverability_test_report_output::Builder {
        crate::output::create_deliverability_test_report_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateDedicatedIpPoolOutput {}
impl std::fmt::Debug for CreateDedicatedIpPoolOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateDedicatedIpPoolOutput");
        formatter.finish()
    }
}
/// See [`CreateDedicatedIpPoolOutput`](crate::output::CreateDedicatedIpPoolOutput)
pub mod create_dedicated_ip_pool_output {
    /// A builder for [`CreateDedicatedIpPoolOutput`](crate::output::CreateDedicatedIpPoolOutput)
    #[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 [`CreateDedicatedIpPoolOutput`](crate::output::CreateDedicatedIpPoolOutput)
        pub fn build(self) -> crate::output::CreateDedicatedIpPoolOutput {
            crate::output::CreateDedicatedIpPoolOutput {}
        }
    }
}
impl CreateDedicatedIpPoolOutput {
    /// Creates a new builder-style object to manufacture [`CreateDedicatedIpPoolOutput`](crate::output::CreateDedicatedIpPoolOutput)
    pub fn builder() -> crate::output::create_dedicated_ip_pool_output::Builder {
        crate::output::create_dedicated_ip_pool_output::Builder::default()
    }
}

/// <p>If the action is successful, the service sends back an HTTP 200 response with an empty HTTP body.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateCustomVerificationEmailTemplateOutput {}
impl std::fmt::Debug for CreateCustomVerificationEmailTemplateOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateCustomVerificationEmailTemplateOutput");
        formatter.finish()
    }
}
/// See [`CreateCustomVerificationEmailTemplateOutput`](crate::output::CreateCustomVerificationEmailTemplateOutput)
pub mod create_custom_verification_email_template_output {
    /// A builder for [`CreateCustomVerificationEmailTemplateOutput`](crate::output::CreateCustomVerificationEmailTemplateOutput)
    #[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 [`CreateCustomVerificationEmailTemplateOutput`](crate::output::CreateCustomVerificationEmailTemplateOutput)
        pub fn build(self) -> crate::output::CreateCustomVerificationEmailTemplateOutput {
            crate::output::CreateCustomVerificationEmailTemplateOutput {}
        }
    }
}
impl CreateCustomVerificationEmailTemplateOutput {
    /// Creates a new builder-style object to manufacture [`CreateCustomVerificationEmailTemplateOutput`](crate::output::CreateCustomVerificationEmailTemplateOutput)
    pub fn builder() -> crate::output::create_custom_verification_email_template_output::Builder {
        crate::output::create_custom_verification_email_template_output::Builder::default()
    }
}

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

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

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateConfigurationSetEventDestinationOutput {}
impl std::fmt::Debug for CreateConfigurationSetEventDestinationOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateConfigurationSetEventDestinationOutput");
        formatter.finish()
    }
}
/// See [`CreateConfigurationSetEventDestinationOutput`](crate::output::CreateConfigurationSetEventDestinationOutput)
pub mod create_configuration_set_event_destination_output {
    /// A builder for [`CreateConfigurationSetEventDestinationOutput`](crate::output::CreateConfigurationSetEventDestinationOutput)
    #[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 [`CreateConfigurationSetEventDestinationOutput`](crate::output::CreateConfigurationSetEventDestinationOutput)
        pub fn build(self) -> crate::output::CreateConfigurationSetEventDestinationOutput {
            crate::output::CreateConfigurationSetEventDestinationOutput {}
        }
    }
}
impl CreateConfigurationSetEventDestinationOutput {
    /// Creates a new builder-style object to manufacture [`CreateConfigurationSetEventDestinationOutput`](crate::output::CreateConfigurationSetEventDestinationOutput)
    pub fn builder() -> crate::output::create_configuration_set_event_destination_output::Builder {
        crate::output::create_configuration_set_event_destination_output::Builder::default()
    }
}

/// <p>An HTTP 200 response if the request succeeds, or an error message if the request fails.</p>
#[non_exhaustive]
#[derive(std::clone::Clone, std::cmp::PartialEq)]
pub struct CreateConfigurationSetOutput {}
impl std::fmt::Debug for CreateConfigurationSetOutput {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut formatter = f.debug_struct("CreateConfigurationSetOutput");
        formatter.finish()
    }
}
/// See [`CreateConfigurationSetOutput`](crate::output::CreateConfigurationSetOutput)
pub mod create_configuration_set_output {
    /// A builder for [`CreateConfigurationSetOutput`](crate::output::CreateConfigurationSetOutput)
    #[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 [`CreateConfigurationSetOutput`](crate::output::CreateConfigurationSetOutput)
        pub fn build(self) -> crate::output::CreateConfigurationSetOutput {
            crate::output::CreateConfigurationSetOutput {}
        }
    }
}
impl CreateConfigurationSetOutput {
    /// Creates a new builder-style object to manufacture [`CreateConfigurationSetOutput`](crate::output::CreateConfigurationSetOutput)
    pub fn builder() -> crate::output::create_configuration_set_output::Builder {
        crate::output::create_configuration_set_output::Builder::default()
    }
}