type AccountDetails struct {

	// The type of email your account is sending. The mail type can be one of the
	// following:
	//
	//     * MARKETING – Most of your sending traffic is to keep your
	// customers informed of your latest offering.
	//
	//     * TRANSACTIONAL – Most of your
	// sending traffic is to communicate during a transaction with a customer.
	MailType MailType

	// The URL of your website. This information helps us better understand the type of
	// content that you plan to send.
	WebsiteURL *string

	// A description of the types of email that you plan to send.
	UseCaseDescription *string

	// Additional email addresses where updates are sent about your account review
	// process.
	AdditionalContactEmailAddresses []*string

	// The language you would prefer for the case. The contact language can be one of
	// ENGLISH or JAPANESE.
	ContactLanguage ContactLanguage

	// Information about the review of the latest details you submitted.
	ReviewDetails *ReviewDetails
}

type AccountSuspendedException struct {
	Message *string
}

type AlreadyExistsException struct {
	Message *string
}

type BadRequestException struct {
	Message *string
}

type BehaviorOnMxFailure string

const (
	BehaviorOnMxFailureUse_default_value BehaviorOnMxFailure = "USE_DEFAULT_VALUE"
	BehaviorOnMxFailureReject_message    BehaviorOnMxFailure = "REJECT_MESSAGE"
)

type BlacklistEntry struct {

	// Additional information about the blacklisting event, as provided by the
	// blacklist maintainer.
	Description *string

	// The time when the blacklisting event occurred, shown in Unix time format.
	ListingTime *time.Time

	// The name of the blacklist that the IP address appears on.
	RblName *string
}

type Body struct {

	// An object that represents the version of the message that is displayed in email
	// clients that support HTML. HTML messages can include formatted text, hyperlinks,
	// images, and more.
	Html *Content

	// An object that represents the version of the message that is displayed in email
	// clients that don't support HTML, or clients where the recipient has disabled
	// HTML rendering.
	Text *Content
}

type BulkEmailContent struct {

	// The template to use for the bulk email message.
	Template *Template
}

type BulkEmailEntry struct {

	// Represents the destination of the message, consisting of To:, CC:, and BCC:
	// fields. Amazon SES does not support the SMTPUTF8 extension, as described in
	// RFC6531 (https://tools.ietf.org/html/rfc6531). For this reason, the local part
	// of a destination email address (the part of the email address that precedes the
	// @ sign) may only contain 7-bit ASCII characters
	// (https://en.wikipedia.org/wiki/Email_address#Local-part). If the domain part of
	// an address (the part after the @ sign) contains non-ASCII characters, they must
	// be encoded using Punycode, as described in RFC3492
	// (https://tools.ietf.org/html/rfc3492.html).
	//
	// This member is required.
	Destination *Destination

	// The ReplacementEmailContent associated with a BulkEmailEntry.
	ReplacementEmailContent *ReplacementEmailContent

	// A list of tags, in the form of name/value pairs, to apply to an email that you
	// send using the SendBulkTemplatedEmail operation. Tags correspond to
	// characteristics of the email that you define, so that you can publish email
	// sending events.
	ReplacementTags []*MessageTag
}

type BulkEmailEntryResult struct {

	// The unique message identifier returned from the SendBulkTemplatedEmail
	// operation.
	MessageId *string

	// A description of an error that prevented a message being sent using the
	// SendBulkTemplatedEmail operation.
	Error *string

	// The status of a message sent using the SendBulkTemplatedEmail operation.
	// Possible values for this parameter include:
	//
	//     * SUCCESS: Amazon SES accepted
	// the message, and will attempt to deliver it to the recipients.
	//
	//     *
	// MESSAGE_REJECTED: The message was rejected because it contained a virus.
	//
	//     *
	// MAIL_FROM_DOMAIN_NOT_VERIFIED: The sender's email address or domain was not
	// verified.
	//
	//     * CONFIGURATION_SET_DOES_NOT_EXIST: The configuration set you
	// specified does not exist.
	//
	//     * TEMPLATE_DOES_NOT_EXIST: The template you
	// specified does not exist.
	//
	//     * ACCOUNT_SUSPENDED: Your account has been shut
	// down because of issues related to your email sending practices.
	//
	//     *
	// ACCOUNT_THROTTLED: The number of emails you can send has been reduced because
	// your account has exceeded its allocated sending limit.
	//
	//     *
	// ACCOUNT_DAILY_QUOTA_EXCEEDED: You have reached or exceeded the maximum number of
	// emails you can send from your account in a 24-hour period.
	//
	//     *
	// INVALID_SENDING_POOL_NAME: The configuration set you specified refers to an IP
	// pool that does not exist.
	//
	//     * ACCOUNT_SENDING_PAUSED: Email sending for the
	// Amazon SES account was disabled using the UpdateAccountSendingEnabled
	// (https://docs.aws.amazon.com/ses/latest/APIReference/API_UpdateAccountSendingEnabled.html)
	// operation.
	//
	//     * CONFIGURATION_SET_SENDING_PAUSED: Email sending for this
	// configuration set was disabled using the UpdateConfigurationSetSendingEnabled
	// (https://docs.aws.amazon.com/ses/latest/APIReference/API_UpdateConfigurationSetSendingEnabled.html)
	// operation.
	//
	//     * INVALID_PARAMETER_VALUE: One or more of the parameters you
	// specified when calling this operation was invalid. See the error message for
	// additional information.
	//
	//     * TRANSIENT_FAILURE: Amazon SES was unable to
	// process your request because of a temporary issue.
	//
	//     * FAILED: Amazon SES was
	// unable to process your request. See the error message for additional
	// information.
	Status BulkEmailStatus
}

type BulkEmailStatus string

const (
	BulkEmailStatusSuccess                          BulkEmailStatus = "SUCCESS"
	BulkEmailStatusMessage_rejected                 BulkEmailStatus = "MESSAGE_REJECTED"
	BulkEmailStatusMail_from_domain_not_verified    BulkEmailStatus = "MAIL_FROM_DOMAIN_NOT_VERIFIED"
	BulkEmailStatusConfiguration_set_not_found      BulkEmailStatus = "CONFIGURATION_SET_NOT_FOUND"
	BulkEmailStatusTemplate_not_found               BulkEmailStatus = "TEMPLATE_NOT_FOUND"
	BulkEmailStatusAccount_suspended                BulkEmailStatus = "ACCOUNT_SUSPENDED"
	BulkEmailStatusAccount_throttled                BulkEmailStatus = "ACCOUNT_THROTTLED"
	BulkEmailStatusAccount_daily_quota_exceeded     BulkEmailStatus = "ACCOUNT_DAILY_QUOTA_EXCEEDED"
	BulkEmailStatusInvalid_sending_pool_name        BulkEmailStatus = "INVALID_SENDING_POOL_NAME"
	BulkEmailStatusAccount_sending_paused           BulkEmailStatus = "ACCOUNT_SENDING_PAUSED"
	BulkEmailStatusConfiguration_set_sending_paused BulkEmailStatus = "CONFIGURATION_SET_SENDING_PAUSED"
	BulkEmailStatusInvalid_parameter                BulkEmailStatus = "INVALID_PARAMETER"
	BulkEmailStatusTransient_failure                BulkEmailStatus = "TRANSIENT_FAILURE"
	BulkEmailStatusFailed                           BulkEmailStatus = "FAILED"
)

type CloudWatchDestination struct {

	// An array of objects that define the dimensions to use when you send email events
	// to Amazon CloudWatch.
	//
	// This member is required.
	DimensionConfigurations []*CloudWatchDimensionConfiguration
}

type CloudWatchDimensionConfiguration struct {

	// The default value of the dimension that is published to Amazon CloudWatch if you
	// don't provide the value of the dimension when you send an email. This value has
	// to meet the following criteria:
	//
	//     * It can only contain ASCII letters (a–z,
	// A–Z), numbers (0–9), underscores (_), or dashes (-).
	//
	//     * It can contain no
	// more than 256 characters.
	//
	// This member is required.
	DefaultDimensionValue *string

	// The name of an Amazon CloudWatch dimension associated with an email sending
	// metric. The name has to meet the following criteria:
	//
	//     * It can only contain
	// ASCII letters (a–z, A–Z), numbers (0–9), underscores (_), or dashes (-).
	//
	//     *
	// It can contain no more than 256 characters.
	//
	// This member is required.
	DimensionName *string

	// The location where the Amazon SES API v2 finds the value of a dimension to
	// publish to Amazon CloudWatch. If you want to use the message tags that you
	// specify using an X-SES-MESSAGE-TAGS header or a parameter to the SendEmail or
	// SendRawEmail API, choose messageTag. If you want to use your own email headers,
	// choose emailHeader. If you want to use link tags, choose linkTags.
	//
	// This member is required.
	DimensionValueSource DimensionValueSource
}

type ConcurrentModificationException struct {
	Message *string
}

type ConflictException struct {
	Message *string
}

type ContactLanguage string

const (
	ContactLanguageEn ContactLanguage = "EN"
	ContactLanguageJa ContactLanguage = "JA"
)

type Content struct {

	// The content of the message itself.
	//
	// This member is required.
	Data *string

	// The character set for the content. Because of the constraints of the SMTP
	// protocol, Amazon SES uses 7-bit ASCII by default. If the text includes
	// characters outside of the ASCII range, you have to specify a character set. For
	// example, you could specify UTF-8, ISO-8859-1, or Shift_JIS.
	Charset *string
}

type CustomVerificationEmailTemplateMetadata struct {

	// The URL that the recipient of the verification email is sent to if his or her
	// address is successfully verified.
	SuccessRedirectionURL *string

	// The email address that the custom verification email is sent from.
	FromEmailAddress *string

	// The name of the custom verification email template.
	TemplateName *string

	// The URL that the recipient of the verification email is sent to if his or her
	// address is not successfully verified.
	FailureRedirectionURL *string

	// The subject line of the custom verification email.
	TemplateSubject *string
}

type DailyVolume struct {

	// An object that contains inbox placement metrics for a specified day in the
	// analysis period, broken out by the recipient's email provider.
	DomainIspPlacements []*DomainIspPlacement

	// The date that the DailyVolume metrics apply to, in Unix time.
	StartDate *time.Time

	// An object that contains inbox placement metrics for a specific day in the
	// analysis period.
	VolumeStatistics *VolumeStatistics
}

type DedicatedIp struct {

	// The warm-up status of a dedicated IP address. The status can have one of the
	// following values:
	//
	//     * IN_PROGRESS – The IP address isn't ready to use because
	// the dedicated IP warm-up process is ongoing.
	//
	//     * DONE – The dedicated IP
	// warm-up process is complete, and the IP address is ready to use.
	//
	// This member is required.
	WarmupStatus WarmupStatus

	// An IPv4 address.
	//
	// This member is required.
	Ip *string

	// The name of the dedicated IP pool that the IP address is associated with.
	PoolName *string

	// Indicates how complete the dedicated IP warm-up process is. When this value
	// equals 1, the address has completed the warm-up process and is ready for use.
	//
	// This member is required.
	WarmupPercentage *int32
}

type DeliverabilityDashboardAccountStatus string

const (
	DeliverabilityDashboardAccountStatusActive             DeliverabilityDashboardAccountStatus = "ACTIVE"
	DeliverabilityDashboardAccountStatusPending_expiration DeliverabilityDashboardAccountStatus = "PENDING_EXPIRATION"
	DeliverabilityDashboardAccountStatusDisabled           DeliverabilityDashboardAccountStatus = "DISABLED"
)

type DeliverabilityTestReport struct {

	// The status of the predictive inbox placement test. If the status is IN_PROGRESS,
	// 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 COMPLETE, then the test is finished, and you can use the
	// GetDeliverabilityTestReport to view the results of the test.
	DeliverabilityTestStatus DeliverabilityTestStatus

	// The sender address that you specified for the predictive inbox placement test.
	FromEmailAddress *string

	// A name that helps you identify a predictive inbox placement test report.
	ReportName *string

	// The subject line for an email that you submitted in a predictive inbox placement
	// test.
	Subject *string

	// A unique string that identifies the predictive inbox placement test.
	ReportId *string

	// The date and time when the predictive inbox placement test was created, in Unix
	// time format.
	CreateDate *time.Time
}

type DeliverabilityTestStatus string

const (
	DeliverabilityTestStatusIn_progress DeliverabilityTestStatus = "IN_PROGRESS"
	DeliverabilityTestStatusCompleted   DeliverabilityTestStatus = "COMPLETED"
)

type DeliveryOptions struct {

	// The name of the dedicated IP pool that you want to associate with the
	// configuration set.
	SendingPoolName *string

	// Specifies whether messages that use the configuration set are required to use
	// Transport Layer Security (TLS). If the value is Require, messages are only
	// delivered if a TLS connection can be established. If the value is Optional,
	// messages can be delivered in plain text if a TLS connection can't be
	// established.
	TlsPolicy TlsPolicy
}

type Destination struct {

	// An array that contains the email addresses of the "To" recipients for the email.
	ToAddresses []*string

	// An array that contains the email addresses of the "BCC" (blind carbon copy)
	// recipients for the email.
	BccAddresses []*string

	// An array that contains the email addresses of the "CC" (carbon copy) recipients
	// for the email.
	CcAddresses []*string
}

type DimensionValueSource string

const (
	DimensionValueSourceMessage_tag  DimensionValueSource = "MESSAGE_TAG"
	DimensionValueSourceEmail_header DimensionValueSource = "EMAIL_HEADER"
	DimensionValueSourceLink_tag     DimensionValueSource = "LINK_TAG"
)

type DkimAttributes struct {

	// If you used Easy DKIM
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html) 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.
	// If you configured DKIM authentication for the domain by providing your own
	// public-private key pair, then this object contains the selector for the public
	// key. 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.
	Tokens []*string

	// A string that indicates how DKIM was configured for the identity. There are two
	// possible values:
	//
	//     * AWS_SES – Indicates that DKIM was configured for the
	// identity by using Easy DKIM
	// (https://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html).
	//
	//     *
	// EXTERNAL – Indicates that DKIM was configured for the identity by using Bring
	// Your Own DKIM (BYODKIM).
	SigningAttributesOrigin DkimSigningAttributesOrigin

	// Describes whether or not Amazon SES has successfully located the DKIM records in
	// the DNS records for the domain. The status can be one of the following:
	//
	//     *
	// PENDING – The verification process was initiated, but Amazon SES hasn't yet
	// detected the DKIM records in the DNS configuration for the domain.
	//
	//     *
	// SUCCESS – The verification process completed successfully.
	//
	//     * FAILED – The
	// verification process failed. This typically occurs when Amazon SES fails to find
	// the DKIM records in the DNS configuration of the domain.
	//
	//     *
	// TEMPORARY_FAILURE – A temporary issue is preventing Amazon SES from determining
	// the DKIM authentication status of the domain.
	//
	//     * NOT_STARTED – The DKIM
	// verification process hasn't been initiated for the domain.
	Status DkimStatus

	// If the value is true, then the messages that you send from the identity are
	// signed using DKIM. If the value is false, then the messages that you send from
	// the identity aren't DKIM-signed.
	SigningEnabled *bool
}

type DkimSigningAttributes struct {

	// A string that's used to identify a public key in the DNS configuration for a
	// domain.
	//
	// This member is required.
	DomainSigningSelector *string

	// A private key that's used to generate a DKIM signature. The private key must use
	// 1024-bit RSA encryption, and must be encoded using base64 encoding.
	//
	// This member is required.
	DomainSigningPrivateKey *string
}

type DkimSigningAttributesOrigin string

const (
	DkimSigningAttributesOriginAws_ses  DkimSigningAttributesOrigin = "AWS_SES"
	DkimSigningAttributesOriginExternal DkimSigningAttributesOrigin = "EXTERNAL"
)

type DkimStatus string

const (
	DkimStatusPending           DkimStatus = "PENDING"
	DkimStatusSuccess           DkimStatus = "SUCCESS"
	DkimStatusFailed            DkimStatus = "FAILED"
	DkimStatusTemporary_failure DkimStatus = "TEMPORARY_FAILURE"
	DkimStatusNot_started       DkimStatus = "NOT_STARTED"
)

type DomainDeliverabilityCampaign struct {

	// The number of email messages that were delivered to recipients’ inboxes.
	InboxCount *int64

	// The URL of an image that contains a snapshot of the email message that was sent.
	ImageUrl *string

	// The percentage of email messages that were opened and then deleted by
	// recipients. Due to technical limitations, this value only includes recipients
	// who opened the message by using an email client that supports images.
	ReadDeleteRate *float64

	// The projected number of recipients that the email message was sent to.
	ProjectedVolume *int64

	// The IP addresses that were used to send the email message.
	SendingIps []*string

	// The number of email messages that were delivered to recipients' spam or junk
	// mail folders.
	SpamCount *int64

	// The percentage of email messages that were opened by recipients. Due to
	// technical limitations, this value only includes recipients who opened the
	// message by using an email client that supports images.
	ReadRate *float64

	// The unique identifier for the campaign. The Deliverability dashboard
	// automatically generates and assigns this identifier to a campaign.
	CampaignId *string

	// The major email providers who handled the email message.
	Esps []*string

	// The verified email address that the email message was sent from.
	FromAddress *string

	// The subject line, or title, of the email message.
	Subject *string

	// The last time, in Unix time format, when the email message was delivered to any
	// recipient's inbox. This value can help you determine how long it took for a
	// campaign to deliver an email message.
	LastSeenDateTime *time.Time

	// The first time, in Unix time format, when the email message was delivered to any
	// recipient's inbox. This value can help you determine how long it took for a
	// campaign to deliver an email message.
	FirstSeenDateTime *time.Time

	// The percentage of email messages that were deleted by recipients, without being
	// opened first. Due to technical limitations, this value only includes recipients
	// who opened the message by using an email client that supports images.
	DeleteRate *float64
}

type DomainDeliverabilityTrackingOption struct {

	// An object that contains information about the inbox placement data settings for
	// the domain.
	InboxPlacementTrackingOption *InboxPlacementTrackingOption

	// A verified domain that’s associated with your AWS account and currently has an
	// active Deliverability dashboard subscription.
	Domain *string

	// The date, in Unix time format, when you enabled the Deliverability dashboard for
	// the domain.
	SubscriptionStartDate *time.Time
}

type DomainIspPlacement struct {

	// The name of the email provider that the inbox placement data applies to.
	IspName *string

	// The percentage of messages that were sent from the selected domain to the
	// specified email provider that arrived in recipients' inboxes.
	InboxPercentage *float64

	// The total number of messages that were sent from the selected domain to the
	// specified email provider that arrived in recipients' spam or junk mail folders.
	SpamRawCount *int64

	// The total number of messages that were sent from the selected domain to the
	// specified email provider that arrived in recipients' inboxes.
	InboxRawCount *int64

	// The percentage of messages that were sent from the selected domain to the
	// specified email provider that arrived in recipients' spam or junk mail folders.
	SpamPercentage *float64
}

type EmailContent struct {

	// The raw email message. The message has to meet the following criteria:
	//
	//     *
	// The message has to contain a header and a body, separated by one blank line.
	//
	//
	// * All of the required header fields must be present in the message.
	//
	//     * Each
	// part of a multipart MIME message must be formatted properly.
	//
	//     * If you
	// include attachments, they must be in a file format that the Amazon SES API v2
	// supports.
	//
	//     * The entire message must be Base64 encoded.
	//
	//     * If any of the
	// MIME parts in your message contain content that is outside of the 7-bit ASCII
	// character range, you should encode that content to ensure that recipients' email
	// clients render the message properly.
	//
	//     * The length of any single line of
	// text in the message can't exceed 1,000 characters. This restriction is defined
	// in RFC 5321 (https://tools.ietf.org/html/rfc5321).
	Raw *RawMessage

	// The simple email message. The message consists of a subject and a message body.
	Simple *Message

	// The template to use for the email message.
	Template *Template
}

type EmailTemplateContent struct {

	// The email body that will be visible to recipients whose email clients do not
	// display HTML.
	Text *string

	// The subject line of the email.
	Subject *string

	// The HTML body of the email.
	Html *string
}

type EmailTemplateMetadata struct {

	// The name of the template.
	TemplateName *string

	// The time and date the template was created.
	CreatedTimestamp *time.Time
}

type EventDestination struct {

	// An object that defines an Amazon SNS destination for email events. You can use
	// Amazon SNS to send notification when certain email events occur.
	SnsDestination *SnsDestination

	// An object that defines an Amazon CloudWatch destination for email events. You
	// can use Amazon CloudWatch to monitor and gain insights on your email sending
	// metrics.
	CloudWatchDestination *CloudWatchDestination

	// If true, the event destination is enabled. When the event destination is
	// enabled, the specified event types are sent to the destinations in this
	// EventDestinationDefinition. If false, the event destination is disabled. When
	// the event destination is disabled, events aren't sent to the specified
	// destinations.
	Enabled *bool

	// An object that defines an Amazon Pinpoint project destination for email events.
	// You can send email event data to a Amazon Pinpoint project to view metrics using
	// the Transactional Messaging dashboards that are built in to Amazon Pinpoint. For
	// more information, see Transactional Messaging Charts
	// (https://docs.aws.amazon.com/pinpoint/latest/userguide/analytics-transactional-messages.html)
	// in the Amazon Pinpoint User Guide.
	PinpointDestination *PinpointDestination

	// The types of events that Amazon SES sends to the specified event destinations.
	//
	// This member is required.
	MatchingEventTypes []EventType

	// A name that identifies the event destination.
	//
	// This member is required.
	Name *string

	// An object that defines an Amazon Kinesis Data Firehose destination for email
	// events. You can use Amazon Kinesis Data Firehose to stream data to other
	// services, such as Amazon S3 and Amazon Redshift.
	KinesisFirehoseDestination *KinesisFirehoseDestination
}

type EventDestinationDefinition struct {

	// An object that defines an Amazon Pinpoint project destination for email events.
	// You can send email event data to a Amazon Pinpoint project to view metrics using
	// the Transactional Messaging dashboards that are built in to Amazon Pinpoint. For
	// more information, see Transactional Messaging Charts
	// (https://docs.aws.amazon.com/pinpoint/latest/userguide/analytics-transactional-messages.html)
	// in the Amazon Pinpoint User Guide.
	PinpointDestination *PinpointDestination

	// If true, the event destination is enabled. When the event destination is
	// enabled, the specified event types are sent to the destinations in this
	// EventDestinationDefinition. If false, the event destination is disabled. When
	// the event destination is disabled, events aren't sent to the specified
	// destinations.
	Enabled *bool

	// An object that defines an Amazon CloudWatch destination for email events. You
	// can use Amazon CloudWatch to monitor and gain insights on your email sending
	// metrics.
	CloudWatchDestination *CloudWatchDestination

	// An object that defines an Amazon SNS destination for email events. You can use
	// Amazon SNS to send notification when certain email events occur.
	SnsDestination *SnsDestination

	// An array that specifies which events the Amazon SES API v2 should send to the
	// destinations in this EventDestinationDefinition.
	MatchingEventTypes []EventType

	// An object that defines an Amazon Kinesis Data Firehose destination for email
	// events. You can use Amazon Kinesis Data Firehose to stream data to other
	// services, such as Amazon S3 and Amazon Redshift.
	KinesisFirehoseDestination *KinesisFirehoseDestination
}

type EventType string

const (
	EventTypeSend              EventType = "SEND"
	EventTypeReject            EventType = "REJECT"
	EventTypeBounce            EventType = "BOUNCE"
	EventTypeComplaint         EventType = "COMPLAINT"
	EventTypeDelivery          EventType = "DELIVERY"
	EventTypeOpen              EventType = "OPEN"
	EventTypeClick             EventType = "CLICK"
	EventTypeRendering_failure EventType = "RENDERING_FAILURE"
	EventTypeDelivery_delay    EventType = "DELIVERY_DELAY"
)

type IdentityInfo struct {

	// Indicates whether or not you can send email from the identity. An identity is an
	// email address or domain that you send email from. Before you can send email from
	// an identity, you have to demostrate that you own the identity, and that you
	// authorize Amazon SES to send email from that identity.
	SendingEnabled *bool

	// The address or domain of the identity.
	IdentityName *string

	// The email identity type. The identity type can be one of the following:
	//
	//     *
	// EMAIL_ADDRESS – The identity is an email address.
	//
	//     * DOMAIN – The identity
	// is a domain.
	//
	//     * MANAGED_DOMAIN – The identity is a domain that is managed by
	// AWS.
	IdentityType IdentityType
}

type IdentityType string

const (
	IdentityTypeEmail_address  IdentityType = "EMAIL_ADDRESS"
	IdentityTypeDomain         IdentityType = "DOMAIN"
	IdentityTypeManaged_domain IdentityType = "MANAGED_DOMAIN"
)

type InboxPlacementTrackingOption struct {

	// Specifies whether inbox placement data is being tracked for the domain.
	Global *bool

	// An array of strings, one for each major email provider that the inbox placement
	// data applies to.
	TrackedIsps []*string
}

type InvalidNextTokenException struct {
	Message *string
}

type IspPlacement struct {

	// The name of the email provider that the inbox placement data applies to.
	IspName *string

	// An object that contains inbox placement metrics for a specific email provider.
	PlacementStatistics *PlacementStatistics
}

type KinesisFirehoseDestination struct {

	// The Amazon Resource Name (ARN) of the IAM role that the Amazon SES API v2 uses
	// to send email events to the Amazon Kinesis Data Firehose stream.
	//
	// This member is required.
	IamRoleArn *string

	// The Amazon Resource Name (ARN) of the Amazon Kinesis Data Firehose stream that
	// the Amazon SES API v2 sends email events to.
	//
	// This member is required.
	DeliveryStreamArn *string
}

type LimitExceededException struct {
	Message *string
}

type MailFromAttributes struct {

	// The status of the MAIL FROM domain. This status can have the following values:
	//
	//
	// * PENDING – Amazon SES hasn't started searching for the MX record yet.
	//
	//     *
	// SUCCESS – Amazon SES detected the required MX record for the MAIL FROM domain.
	//
	//
	// * FAILED – Amazon SES can't find the required MX record, or the record no longer
	// exists.
	//
	//     * TEMPORARY_FAILURE – A temporary issue occurred, which prevented
	// Amazon SES from determining the status of the MAIL FROM domain.
	//
	// This member is required.
	MailFromDomainStatus MailFromDomainStatus

	// The name of a domain that an email identity uses as a custom MAIL FROM domain.
	//
	// This member is required.
	MailFromDomain *string

	// The action that you want to take if the required MX record can't be found when
	// you send an email. When you set this value to UseDefaultValue, the mail is sent
	// using amazonses.com as the MAIL FROM domain. When you set this value to
	// RejectMessage, the Amazon SES API v2 returns a MailFromDomainNotVerified error,
	// and doesn't attempt to deliver the email. These behaviors are taken when the
	// custom MAIL FROM domain configuration is in the Pending, Failed, and
	// TemporaryFailure states.
	//
	// This member is required.
	BehaviorOnMxFailure BehaviorOnMxFailure
}

type MailFromDomainNotVerifiedException struct {
	Message *string
}

type MailFromDomainStatus string

const (
	MailFromDomainStatusPending           MailFromDomainStatus = "PENDING"
	MailFromDomainStatusSuccess           MailFromDomainStatus = "SUCCESS"
	MailFromDomainStatusFailed            MailFromDomainStatus = "FAILED"
	MailFromDomainStatusTemporary_failure MailFromDomainStatus = "TEMPORARY_FAILURE"
)

type MailType string

const (
	MailTypeMarketing     MailType = "MARKETING"
	MailTypeTransactional MailType = "TRANSACTIONAL"
)

type Message struct {

	// The body of the message. You can specify an HTML version of the message, a
	// text-only version of the message, or both.
	//
	// This member is required.
	Body *Body

	// The subject line of the email. The subject line can only contain 7-bit ASCII
	// characters. However, you can specify non-ASCII characters in the subject line by
	// using encoded-word syntax, as described in RFC 2047
	// (https://tools.ietf.org/html/rfc2047).
	//
	// This member is required.
	Subject *Content
}

type MessageRejected struct {
	Message *string
}

type MessageTag struct {

	// The value of the message tag. The message tag value has to meet the following
	// criteria:
	//
	//     * It can only contain ASCII letters (a–z, A–Z), numbers (0–9),
	// underscores (_), or dashes (-).
	//
	//     * It can contain no more than 256
	// characters.
	//
	// This member is required.
	Value *string

	// The name of the message tag. The message tag name has to meet the following
	// criteria:
	//
	//     * It can only contain ASCII letters (a–z, A–Z), numbers (0–9),
	// underscores (_), or dashes (-).
	//
	//     * It can contain no more than 256
	// characters.
	//
	// This member is required.
	Name *string
}

type NotFoundException struct {
	Message *string
}

type OverallVolume struct {

	// An object that contains inbox and junk mail placement metrics for individual
	// email providers.
	DomainIspPlacements []*DomainIspPlacement

	// An object that contains information about the numbers of messages that arrived
	// in recipients' inboxes and junk mail folders.
	VolumeStatistics *VolumeStatistics

	// The percentage of emails that were sent from the domain that were read by their
	// recipients.
	ReadRatePercent *float64
}

type PinpointDestination struct {

	// The Amazon Resource Name (ARN) of the Amazon Pinpoint project that you want to
	// send email events to.
	ApplicationArn *string
}

type PlacementStatistics struct {

	// The percentage of emails that arrived in recipients' inboxes during the
	// predictive inbox placement test.
	InboxPercentage *float64

	// The percentage of emails that were authenticated by using Sender Policy
	// Framework (SPF) during the predictive inbox placement test.
	SpfPercentage *float64

	// The percentage of emails that were authenticated by using DomainKeys Identified
	// Mail (DKIM) during the predictive inbox placement test.
	DkimPercentage *float64

	// The percentage of emails that arrived in recipients' spam or junk mail folders
	// during the predictive inbox placement test.
	SpamPercentage *float64

	// The percentage of emails that didn't arrive in recipients' inboxes at all during
	// the predictive inbox placement test.
	MissingPercentage *float64
}

type RawMessage struct {

	// The raw email message. The message has to meet the following criteria:
	//
	//     *
	// The message has to contain a header and a body, separated by one blank line.
	//
	//
	// * All of the required header fields must be present in the message.
	//
	//     * Each
	// part of a multipart MIME message must be formatted properly.
	//
	//     * Attachments
	// must be in a file format that the Amazon SES supports.
	//
	//     * The entire message
	// must be Base64 encoded.
	//
	//     * If any of the MIME parts in your message contain
	// content that is outside of the 7-bit ASCII character range, you should encode
	// that content to ensure that recipients' email clients render the message
	// properly.
	//
	//     * The length of any single line of text in the message can't
	// exceed 1,000 characters. This restriction is defined in RFC 5321
	// (https://tools.ietf.org/html/rfc5321).
	//
	// This member is required.
	Data []byte
}

type ReplacementEmailContent struct {

	// The ReplacementTemplate associated with ReplacementEmailContent.
	ReplacementTemplate *ReplacementTemplate
}

type ReplacementTemplate struct {

	// A list of replacement values to apply to the template. This parameter is a JSON
	// object, typically consisting of key-value pairs in which the keys correspond to
	// replacement tags in the email template.
	ReplacementTemplateData *string
}

type ReputationOptions struct {

	// If true, tracking of reputation metrics is enabled for the configuration set. If
	// false, tracking of reputation metrics is disabled for the configuration set.
	ReputationMetricsEnabled *bool

	// The date and time (in Unix time) when the reputation metrics were last given a
	// fresh start. When your account is given a fresh start, your reputation metrics
	// are calculated starting from the date of the fresh start.
	LastFreshStart *time.Time
}

type ReviewDetails struct {

	// The status of the latest review of your account. The status can be one of the
	// following:
	//
	//     * PENDING – We have received your appeal and are in the process
	// of reviewing it.
	//
	//     * GRANTED – Your appeal has been reviewed and your
	// production access has been granted.
	//
	//     * DENIED – Your appeal has been
	// reviewed and your production access has been denied.
	//
	//     * FAILED – An internal
	// error occurred and we didn't receive your appeal. You can submit your appeal
	// again.
	Status ReviewStatus

	// The associated support center case ID (if any).
	CaseId *string
}

type ReviewStatus string

const (
	ReviewStatusPending ReviewStatus = "PENDING"
	ReviewStatusFailed  ReviewStatus = "FAILED"
	ReviewStatusGranted ReviewStatus = "GRANTED"
	ReviewStatusDenied  ReviewStatus = "DENIED"
)

type SendQuota struct {

	// The maximum number of emails that you can send in the current AWS Region over a
	// 24-hour period. This value is also called your sending quota.
	Max24HourSend *float64

	// The maximum number of emails that you can send per second in the current AWS
	// Region. This value is also called your maximum sending rate or your maximum TPS
	// (transactions per second) rate.
	MaxSendRate *float64

	// The number of emails sent from your Amazon SES account in the current AWS Region
	// over the past 24 hours.
	SentLast24Hours *float64
}

type SendingOptions struct {

	// If true, email sending is enabled for the configuration set. If false, email
	// sending is disabled for the configuration set.
	SendingEnabled *bool
}

type SendingPausedException struct {
	Message *string
}

type SnsDestination struct {

	// The Amazon Resource Name (ARN) of the Amazon SNS topic that you want to publish
	// email events to. For more information about Amazon SNS topics, see the Amazon
	// SNS Developer Guide
	// (https://docs.aws.amazon.com/sns/latest/dg/CreateTopic.html).
	//
	// This member is required.
	TopicArn *string
}

type SuppressedDestination struct {

	// The email address that is on the suppression list for your account.
	//
	// This member is required.
	EmailAddress *string

	// The date and time when the suppressed destination was last updated, shown in
	// Unix time format.
	//
	// This member is required.
	LastUpdateTime *time.Time

	// The reason that the address was added to the suppression list for your account.
	//
	// This member is required.
	Reason SuppressionListReason

	// An optional value that can contain additional information about the reasons that
	// the address was added to the suppression list for your account.
	Attributes *SuppressedDestinationAttributes
}

type SuppressedDestinationAttributes struct {

	// The unique identifier of the email message that caused the email address to be
	// added to the suppression list for your account.
	MessageId *string

	// A unique identifier that's generated when an email address is added to the
	// suppression list for your account.
	FeedbackId *string
}

type SuppressedDestinationSummary struct {

	// The reason that the address was added to the suppression list for your account.
	//
	// This member is required.
	Reason SuppressionListReason

	// The email address that's on the suppression list for your account.
	//
	// This member is required.
	EmailAddress *string

	// The date and time when the suppressed destination was last updated, shown in
	// Unix time format.
	//
	// This member is required.
	LastUpdateTime *time.Time
}

type SuppressionAttributes struct {

	// A list that contains the reasons that email addresses will be automatically
	// added to the suppression list for your account. This list can contain any or all
	// of the following:
	//
	//     * COMPLAINT – Amazon SES adds an email address to the
	// suppression list for your account when a message sent to that address results in
	// a complaint.
	//
	//     * BOUNCE – Amazon SES adds an email address to the suppression
	// list for your account when a message sent to that address results in a hard
	// bounce.
	SuppressedReasons []SuppressionListReason
}

type SuppressionListReason string

const (
	SuppressionListReasonBounce    SuppressionListReason = "BOUNCE"
	SuppressionListReasonComplaint SuppressionListReason = "COMPLAINT"
)

type SuppressionOptions struct {

	// A list that contains the reasons that email addresses are automatically added to
	// the suppression list for your account. This list can contain any or all of the
	// following:
	//
	//     * COMPLAINT – Amazon SES adds an email address to the
	// suppression list for your account when a message sent to that address results in
	// a complaint.
	//
	//     * BOUNCE – Amazon SES adds an email address to the suppression
	// list for your account when a message sent to that address results in a hard
	// bounce.
	SuppressedReasons []SuppressionListReason
}

type Tag struct {

	// The optional part of a key-value pair that defines a tag. The maximum length of
	// a tag value is 256 characters. The minimum length is 0 characters. If you don't
	// want a resource to have a specific tag value, don't specify a value for this
	// parameter. If you don't specify a value, Amazon SES sets the value to an empty
	// string.
	//
	// This member is required.
	Value *string

	// One part of a key-value pair that defines a tag. The maximum length of a tag key
	// is 128 characters. The minimum length is 1 character.
	//
	// This member is required.
	Key *string
}

type Template struct {

	// The Amazon Resource Name (ARN) of the template.
	TemplateArn *string

	// An object that defines the values to use for message variables in the template.
	// This object is a set of key-value pairs. Each key defines a message variable in
	// the template. The corresponding value defines the value to use for that
	// variable.
	TemplateData *string

	// The name of the template. You will refer to this name when you send email using
	// the SendTemplatedEmail or SendBulkTemplatedEmail operations.
	TemplateName *string
}

type TlsPolicy string

const (
	TlsPolicyRequire  TlsPolicy = "REQUIRE"
	TlsPolicyOptional TlsPolicy = "OPTIONAL"
)

type TooManyRequestsException struct {
	Message *string
}

type TrackingOptions struct {

	// The domain that you want to use for tracking open and click events.
	//
	// This member is required.
	CustomRedirectDomain *string
}

type VolumeStatistics struct {

	// The total number of emails that arrived in recipients' inboxes.
	InboxRawCount *int64

	// An estimate of the percentage of emails sent from the current domain that will
	// arrive in recipients' spam or junk mail folders.
	ProjectedSpam *int64

	// An estimate of the percentage of emails sent from the current domain that will
	// arrive in recipients' inboxes.
	ProjectedInbox *int64

	// The total number of emails that arrived in recipients' spam or junk mail
	// folders.
	SpamRawCount *int64
}

type WarmupStatus string

const (
	WarmupStatusIn_progress WarmupStatus = "IN_PROGRESS"
	WarmupStatusDone        WarmupStatus = "DONE"
)