api.go

// THIS FILE IS AUTOMATICALLY GENERATED. DO NOT EDIT.

// Package ses provides a client for Amazon Simple Email Service.
package ses

import (
	"time"

	"github.com/aws/aws-sdk-go/aws"
)

const opDeleteIdentity = "DeleteIdentity"

// DeleteIdentityRequest generates a request for the DeleteIdentity operation.
func (c *SES) DeleteIdentityRequest(input *DeleteIdentityInput) (req *aws.Request, output *DeleteIdentityOutput) {
	op := &aws.Operation{
		Name:       opDeleteIdentity,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteIdentityInput{}
	}

	req = c.newRequest(op, input, output)
	output = &DeleteIdentityOutput{}
	req.Data = output
	return
}

// Deletes the specified identity (email address or domain) from the list of
// verified identities.
//
// This action is throttled at one request per second.
func (c *SES) DeleteIdentity(input *DeleteIdentityInput) (*DeleteIdentityOutput, error) {
	req, out := c.DeleteIdentityRequest(input)
	err := req.Send()
	return out, err
}

const opDeleteVerifiedEmailAddress = "DeleteVerifiedEmailAddress"

// DeleteVerifiedEmailAddressRequest generates a request for the DeleteVerifiedEmailAddress operation.
func (c *SES) DeleteVerifiedEmailAddressRequest(input *DeleteVerifiedEmailAddressInput) (req *aws.Request, output *DeleteVerifiedEmailAddressOutput) {
	op := &aws.Operation{
		Name:       opDeleteVerifiedEmailAddress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &DeleteVerifiedEmailAddressInput{}
	}

	req = c.newRequest(op, input, output)
	output = &DeleteVerifiedEmailAddressOutput{}
	req.Data = output
	return
}

// Deletes the specified email address from the list of verified addresses.
//
// The DeleteVerifiedEmailAddress action is deprecated as of the May 15, 2012
// release of Domain Verification. The DeleteIdentity action is now preferred.
// This action is throttled at one request per second.
func (c *SES) DeleteVerifiedEmailAddress(input *DeleteVerifiedEmailAddressInput) (*DeleteVerifiedEmailAddressOutput, error) {
	req, out := c.DeleteVerifiedEmailAddressRequest(input)
	err := req.Send()
	return out, err
}

const opGetIdentityDKIMAttributes = "GetIdentityDkimAttributes"

// GetIdentityDKIMAttributesRequest generates a request for the GetIdentityDKIMAttributes operation.
func (c *SES) GetIdentityDKIMAttributesRequest(input *GetIdentityDKIMAttributesInput) (req *aws.Request, output *GetIdentityDKIMAttributesOutput) {
	op := &aws.Operation{
		Name:       opGetIdentityDKIMAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetIdentityDKIMAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &GetIdentityDKIMAttributesOutput{}
	req.Data = output
	return
}

// Returns the current status of Easy DKIM signing for an entity. For domain
// name identities, this action also returns the DKIM tokens that are required
// for Easy DKIM signing, and whether Amazon SES has successfully verified that
// these tokens have been published.
//
// This action takes a list of identities as input and returns the following
// information for each:
//
//  Whether Easy DKIM signing is enabled or disabled. A set of DKIM tokens
// that represent the identity. If the identity is an email address, the tokens
// represent the domain of that address. Whether Amazon SES has successfully
// verified the DKIM tokens published in the domain's DNS. This information
// is only returned for domain name identities, not for email addresses.  This
// action is throttled at one request per second and can only get DKIM attributes
// for up to 100 identities at a time.
//
// For more information about creating DNS records using DKIM tokens, go to
// the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
func (c *SES) GetIdentityDKIMAttributes(input *GetIdentityDKIMAttributesInput) (*GetIdentityDKIMAttributesOutput, error) {
	req, out := c.GetIdentityDKIMAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opGetIdentityNotificationAttributes = "GetIdentityNotificationAttributes"

// GetIdentityNotificationAttributesRequest generates a request for the GetIdentityNotificationAttributes operation.
func (c *SES) GetIdentityNotificationAttributesRequest(input *GetIdentityNotificationAttributesInput) (req *aws.Request, output *GetIdentityNotificationAttributesOutput) {
	op := &aws.Operation{
		Name:       opGetIdentityNotificationAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetIdentityNotificationAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &GetIdentityNotificationAttributesOutput{}
	req.Data = output
	return
}

// Given a list of verified identities (email addresses and/or domains), returns
// a structure describing identity notification attributes.
//
// This action is throttled at one request per second and can only get notification
// attributes for up to 100 identities at a time.
//
// For more information about using notifications with Amazon SES, see the
// Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html).
func (c *SES) GetIdentityNotificationAttributes(input *GetIdentityNotificationAttributesInput) (*GetIdentityNotificationAttributesOutput, error) {
	req, out := c.GetIdentityNotificationAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opGetIdentityVerificationAttributes = "GetIdentityVerificationAttributes"

// GetIdentityVerificationAttributesRequest generates a request for the GetIdentityVerificationAttributes operation.
func (c *SES) GetIdentityVerificationAttributesRequest(input *GetIdentityVerificationAttributesInput) (req *aws.Request, output *GetIdentityVerificationAttributesOutput) {
	op := &aws.Operation{
		Name:       opGetIdentityVerificationAttributes,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetIdentityVerificationAttributesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &GetIdentityVerificationAttributesOutput{}
	req.Data = output
	return
}

// Given a list of identities (email addresses and/or domains), returns the
// verification status and (for domain identities) the verification token for
// each identity.
//
// This action is throttled at one request per second and can only get verification
// attributes for up to 100 identities at a time.
func (c *SES) GetIdentityVerificationAttributes(input *GetIdentityVerificationAttributesInput) (*GetIdentityVerificationAttributesOutput, error) {
	req, out := c.GetIdentityVerificationAttributesRequest(input)
	err := req.Send()
	return out, err
}

const opGetSendQuota = "GetSendQuota"

// GetSendQuotaRequest generates a request for the GetSendQuota operation.
func (c *SES) GetSendQuotaRequest(input *GetSendQuotaInput) (req *aws.Request, output *GetSendQuotaOutput) {
	op := &aws.Operation{
		Name:       opGetSendQuota,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSendQuotaInput{}
	}

	req = c.newRequest(op, input, output)
	output = &GetSendQuotaOutput{}
	req.Data = output
	return
}

// Returns the user's current sending limits.
//
// This action is throttled at one request per second.
func (c *SES) GetSendQuota(input *GetSendQuotaInput) (*GetSendQuotaOutput, error) {
	req, out := c.GetSendQuotaRequest(input)
	err := req.Send()
	return out, err
}

const opGetSendStatistics = "GetSendStatistics"

// GetSendStatisticsRequest generates a request for the GetSendStatistics operation.
func (c *SES) GetSendStatisticsRequest(input *GetSendStatisticsInput) (req *aws.Request, output *GetSendStatisticsOutput) {
	op := &aws.Operation{
		Name:       opGetSendStatistics,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &GetSendStatisticsInput{}
	}

	req = c.newRequest(op, input, output)
	output = &GetSendStatisticsOutput{}
	req.Data = output
	return
}

// Returns the user's sending statistics. The result is a list of data points,
// representing the last two weeks of sending activity.
//
// Each data point in the list contains statistics for a 15-minute interval.
//
// This action is throttled at one request per second.
func (c *SES) GetSendStatistics(input *GetSendStatisticsInput) (*GetSendStatisticsOutput, error) {
	req, out := c.GetSendStatisticsRequest(input)
	err := req.Send()
	return out, err
}

const opListIdentities = "ListIdentities"

// ListIdentitiesRequest generates a request for the ListIdentities operation.
func (c *SES) ListIdentitiesRequest(input *ListIdentitiesInput) (req *aws.Request, output *ListIdentitiesOutput) {
	op := &aws.Operation{
		Name:       opListIdentities,
		HTTPMethod: "POST",
		HTTPPath:   "/",
		Paginator: &aws.Paginator{
			InputTokens:     []string{"NextToken"},
			OutputTokens:    []string{"NextToken"},
			LimitToken:      "MaxItems",
			TruncationToken: "",
		},
	}

	if input == nil {
		input = &ListIdentitiesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &ListIdentitiesOutput{}
	req.Data = output
	return
}

// Returns a list containing all of the identities (email addresses and domains)
// for a specific AWS Account, regardless of verification status.
//
// This action is throttled at one request per second.
func (c *SES) ListIdentities(input *ListIdentitiesInput) (*ListIdentitiesOutput, error) {
	req, out := c.ListIdentitiesRequest(input)
	err := req.Send()
	return out, err
}

func (c *SES) ListIdentitiesPages(input *ListIdentitiesInput, fn func(p *ListIdentitiesOutput, lastPage bool) (shouldContinue bool)) error {
	page, _ := c.ListIdentitiesRequest(input)
	return page.EachPage(func(p interface{}, lastPage bool) bool {
		return fn(p.(*ListIdentitiesOutput), lastPage)
	})
}

const opListVerifiedEmailAddresses = "ListVerifiedEmailAddresses"

// ListVerifiedEmailAddressesRequest generates a request for the ListVerifiedEmailAddresses operation.
func (c *SES) ListVerifiedEmailAddressesRequest(input *ListVerifiedEmailAddressesInput) (req *aws.Request, output *ListVerifiedEmailAddressesOutput) {
	op := &aws.Operation{
		Name:       opListVerifiedEmailAddresses,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &ListVerifiedEmailAddressesInput{}
	}

	req = c.newRequest(op, input, output)
	output = &ListVerifiedEmailAddressesOutput{}
	req.Data = output
	return
}

// Returns a list containing all of the email addresses that have been verified.
//
// The ListVerifiedEmailAddresses action is deprecated as of the May 15, 2012
// release of Domain Verification. The ListIdentities action is now preferred.
// This action is throttled at one request per second.
func (c *SES) ListVerifiedEmailAddresses(input *ListVerifiedEmailAddressesInput) (*ListVerifiedEmailAddressesOutput, error) {
	req, out := c.ListVerifiedEmailAddressesRequest(input)
	err := req.Send()
	return out, err
}

const opSendEmail = "SendEmail"

// SendEmailRequest generates a request for the SendEmail operation.
func (c *SES) SendEmailRequest(input *SendEmailInput) (req *aws.Request, output *SendEmailOutput) {
	op := &aws.Operation{
		Name:       opSendEmail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SendEmailInput{}
	}

	req = c.newRequest(op, input, output)
	output = &SendEmailOutput{}
	req.Data = output
	return
}

// Composes an email message based on input data, and then immediately queues
// the message for sending.
//
//  You can only send email from verified email addresses and domains. If your
// account is still in the Amazon SES sandbox, you must also verify every recipient
// email address except for the recipients provided by the Amazon SES mailbox
// simulator. For more information, go to the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html).
//  The total size of the message cannot exceed 10 MB.
//
// Amazon SES has a limit on the total number of recipients per message: The
// combined number of To:, CC: and BCC: email addresses cannot exceed 50. If
// you need to send an email message to a larger audience, you can divide your
// recipient list into groups of 50 or fewer, and then call Amazon SES repeatedly
// to send the message to each group.
//
// For every message that you send, the total number of recipients (To:, CC:
// and BCC:) is counted against your sending quota - the maximum number of emails
// you can send in a 24-hour period. For information about your sending quota,
// go to the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html).
func (c *SES) SendEmail(input *SendEmailInput) (*SendEmailOutput, error) {
	req, out := c.SendEmailRequest(input)
	err := req.Send()
	return out, err
}

const opSendRawEmail = "SendRawEmail"

// SendRawEmailRequest generates a request for the SendRawEmail operation.
func (c *SES) SendRawEmailRequest(input *SendRawEmailInput) (req *aws.Request, output *SendRawEmailOutput) {
	op := &aws.Operation{
		Name:       opSendRawEmail,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SendRawEmailInput{}
	}

	req = c.newRequest(op, input, output)
	output = &SendRawEmailOutput{}
	req.Data = output
	return
}

// Sends an email message, with header and content specified by the client.
// The SendRawEmail action is useful for sending multipart MIME emails. The
// raw text of the message must comply with Internet email standards; otherwise,
// the message cannot be sent.
//
//  You can only send email from verified email addresses and domains. If your
// account is still in the Amazon SES sandbox, you must also verify every recipient
// email address except for the recipients provided by the Amazon SES mailbox
// simulator. For more information, go to the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/verify-addresses-and-domains.html).
//  The total size of the message cannot exceed 10 MB. This includes any attachments
// that are part of the message.
//
// Amazon SES has a limit on the total number of recipients per message: The
// combined number of To:, CC: and BCC: email addresses cannot exceed 50. If
// you need to send an email message to a larger audience, you can divide your
// recipient list into groups of 50 or fewer, and then call Amazon SES repeatedly
// to send the message to each group.
//
// The To:, CC:, and BCC: headers in the raw message can contain a group list.
// Note that each recipient in a group list counts towards the 50-recipient
// limit.
//
// For every message that you send, the total number of recipients (To:, CC:
// and BCC:) is counted against your sending quota - the maximum number of emails
// you can send in a 24-hour period. For information about your sending quota,
// go to the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/manage-sending-limits.html).
func (c *SES) SendRawEmail(input *SendRawEmailInput) (*SendRawEmailOutput, error) {
	req, out := c.SendRawEmailRequest(input)
	err := req.Send()
	return out, err
}

const opSetIdentityDKIMEnabled = "SetIdentityDkimEnabled"

// SetIdentityDKIMEnabledRequest generates a request for the SetIdentityDKIMEnabled operation.
func (c *SES) SetIdentityDKIMEnabledRequest(input *SetIdentityDKIMEnabledInput) (req *aws.Request, output *SetIdentityDKIMEnabledOutput) {
	op := &aws.Operation{
		Name:       opSetIdentityDKIMEnabled,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SetIdentityDKIMEnabledInput{}
	}

	req = c.newRequest(op, input, output)
	output = &SetIdentityDKIMEnabledOutput{}
	req.Data = output
	return
}

// Enables or disables Easy DKIM signing of email sent from an identity:
//
//  If Easy DKIM signing is enabled for a domain name identity (e.g., example.com),
// then Amazon SES will DKIM-sign all email sent by addresses under that domain
// name (e.g., user@example.com). If Easy DKIM signing is enabled for an email
// address, then Amazon SES will DKIM-sign all email sent by that email address.
//  For email addresses (e.g., user@example.com), you can only enable Easy DKIM
// signing if the corresponding domain (e.g., example.com) has been set up for
// Easy DKIM using the AWS Console or the VerifyDomainDkim action.
//
// This action is throttled at one request per second.
//
// For more information about Easy DKIM signing, go to the Amazon SES Developer
// Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim.html).
func (c *SES) SetIdentityDKIMEnabled(input *SetIdentityDKIMEnabledInput) (*SetIdentityDKIMEnabledOutput, error) {
	req, out := c.SetIdentityDKIMEnabledRequest(input)
	err := req.Send()
	return out, err
}

const opSetIdentityFeedbackForwardingEnabled = "SetIdentityFeedbackForwardingEnabled"

// SetIdentityFeedbackForwardingEnabledRequest generates a request for the SetIdentityFeedbackForwardingEnabled operation.
func (c *SES) SetIdentityFeedbackForwardingEnabledRequest(input *SetIdentityFeedbackForwardingEnabledInput) (req *aws.Request, output *SetIdentityFeedbackForwardingEnabledOutput) {
	op := &aws.Operation{
		Name:       opSetIdentityFeedbackForwardingEnabled,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SetIdentityFeedbackForwardingEnabledInput{}
	}

	req = c.newRequest(op, input, output)
	output = &SetIdentityFeedbackForwardingEnabledOutput{}
	req.Data = output
	return
}

// Given an identity (email address or domain), enables or disables whether
// Amazon SES forwards bounce and complaint notifications as email. Feedback
// forwarding can only be disabled when Amazon Simple Notification Service (Amazon
// SNS) topics are specified for both bounces and complaints.
//
// Feedback forwarding does not apply to delivery notifications. Delivery notifications
// are only available through Amazon SNS. This action is throttled at one request
// per second.
//
// For more information about using notifications with Amazon SES, see the
// Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html).
func (c *SES) SetIdentityFeedbackForwardingEnabled(input *SetIdentityFeedbackForwardingEnabledInput) (*SetIdentityFeedbackForwardingEnabledOutput, error) {
	req, out := c.SetIdentityFeedbackForwardingEnabledRequest(input)
	err := req.Send()
	return out, err
}

const opSetIdentityNotificationTopic = "SetIdentityNotificationTopic"

// SetIdentityNotificationTopicRequest generates a request for the SetIdentityNotificationTopic operation.
func (c *SES) SetIdentityNotificationTopicRequest(input *SetIdentityNotificationTopicInput) (req *aws.Request, output *SetIdentityNotificationTopicOutput) {
	op := &aws.Operation{
		Name:       opSetIdentityNotificationTopic,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &SetIdentityNotificationTopicInput{}
	}

	req = c.newRequest(op, input, output)
	output = &SetIdentityNotificationTopicOutput{}
	req.Data = output
	return
}

// Given an identity (email address or domain), sets the Amazon Simple Notification
// Service (Amazon SNS) topic to which Amazon SES will publish bounce, complaint,
// and/or delivery notifications for emails sent with that identity as the Source.
//
// Unless feedback forwarding is enabled, you must specify Amazon SNS topics
// for bounce and complaint notifications. For more information, see SetIdentityFeedbackForwardingEnabled.
//  This action is throttled at one request per second.
//
// For more information about feedback notification, see the Amazon SES Developer
// Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/notifications.html).
func (c *SES) SetIdentityNotificationTopic(input *SetIdentityNotificationTopicInput) (*SetIdentityNotificationTopicOutput, error) {
	req, out := c.SetIdentityNotificationTopicRequest(input)
	err := req.Send()
	return out, err
}

const opVerifyDomainDKIM = "VerifyDomainDkim"

// VerifyDomainDKIMRequest generates a request for the VerifyDomainDKIM operation.
func (c *SES) VerifyDomainDKIMRequest(input *VerifyDomainDKIMInput) (req *aws.Request, output *VerifyDomainDKIMOutput) {
	op := &aws.Operation{
		Name:       opVerifyDomainDKIM,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyDomainDKIMInput{}
	}

	req = c.newRequest(op, input, output)
	output = &VerifyDomainDKIMOutput{}
	req.Data = output
	return
}

// Returns a set of DKIM tokens for a domain. DKIM tokens are character strings
// that represent your domain's identity. Using these tokens, you will need
// to create DNS CNAME records that point to DKIM public keys hosted by Amazon
// SES. Amazon Web Services will eventually detect that you have updated your
// DNS records; this detection process may take up to 72 hours. Upon successful
// detection, Amazon SES will be able to DKIM-sign email originating from that
// domain.
//
// This action is throttled at one request per second.
//
// To enable or disable Easy DKIM signing for a domain, use the SetIdentityDkimEnabled
// action.
//
// For more information about creating DNS records using DKIM tokens, go to
// the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
func (c *SES) VerifyDomainDKIM(input *VerifyDomainDKIMInput) (*VerifyDomainDKIMOutput, error) {
	req, out := c.VerifyDomainDKIMRequest(input)
	err := req.Send()
	return out, err
}

const opVerifyDomainIdentity = "VerifyDomainIdentity"

// VerifyDomainIdentityRequest generates a request for the VerifyDomainIdentity operation.
func (c *SES) VerifyDomainIdentityRequest(input *VerifyDomainIdentityInput) (req *aws.Request, output *VerifyDomainIdentityOutput) {
	op := &aws.Operation{
		Name:       opVerifyDomainIdentity,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyDomainIdentityInput{}
	}

	req = c.newRequest(op, input, output)
	output = &VerifyDomainIdentityOutput{}
	req.Data = output
	return
}

// Verifies a domain.
//
// This action is throttled at one request per second.
func (c *SES) VerifyDomainIdentity(input *VerifyDomainIdentityInput) (*VerifyDomainIdentityOutput, error) {
	req, out := c.VerifyDomainIdentityRequest(input)
	err := req.Send()
	return out, err
}

const opVerifyEmailAddress = "VerifyEmailAddress"

// VerifyEmailAddressRequest generates a request for the VerifyEmailAddress operation.
func (c *SES) VerifyEmailAddressRequest(input *VerifyEmailAddressInput) (req *aws.Request, output *VerifyEmailAddressOutput) {
	op := &aws.Operation{
		Name:       opVerifyEmailAddress,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyEmailAddressInput{}
	}

	req = c.newRequest(op, input, output)
	output = &VerifyEmailAddressOutput{}
	req.Data = output
	return
}

// Verifies an email address. This action causes a confirmation email message
// to be sent to the specified address.
//
// The VerifyEmailAddress action is deprecated as of the May 15, 2012 release
// of Domain Verification. The VerifyEmailIdentity action is now preferred.
// This action is throttled at one request per second.
func (c *SES) VerifyEmailAddress(input *VerifyEmailAddressInput) (*VerifyEmailAddressOutput, error) {
	req, out := c.VerifyEmailAddressRequest(input)
	err := req.Send()
	return out, err
}

const opVerifyEmailIdentity = "VerifyEmailIdentity"

// VerifyEmailIdentityRequest generates a request for the VerifyEmailIdentity operation.
func (c *SES) VerifyEmailIdentityRequest(input *VerifyEmailIdentityInput) (req *aws.Request, output *VerifyEmailIdentityOutput) {
	op := &aws.Operation{
		Name:       opVerifyEmailIdentity,
		HTTPMethod: "POST",
		HTTPPath:   "/",
	}

	if input == nil {
		input = &VerifyEmailIdentityInput{}
	}

	req = c.newRequest(op, input, output)
	output = &VerifyEmailIdentityOutput{}
	req.Data = output
	return
}

// Verifies an email address. This action causes a confirmation email message
// to be sent to the specified address.
//
// This action is throttled at one request per second.
func (c *SES) VerifyEmailIdentity(input *VerifyEmailIdentityInput) (*VerifyEmailIdentityOutput, error) {
	req, out := c.VerifyEmailIdentityRequest(input)
	err := req.Send()
	return out, err
}

// Represents the body of the message. You can specify text, HTML, or both.
// If you use both, then the message should display correctly in the widest
// variety of email clients.
type Body struct {
	// The content of the message, in HTML format. Use this for email clients that
	// can process HTML. You can include clickable links, formatted text, and much
	// more in an HTML message.
	HTML *Content `locationName:"Html" type:"structure"`

	// The content of the message, in text format. Use this for text-based email
	// clients, or clients on high-latency networks (such as mobile devices).
	Text *Content `type:"structure"`

	metadataBody `json:"-" xml:"-"`
}

type metadataBody struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents textual data, plus an optional character set specification.
//
// By default, the text must be 7-bit ASCII, due to the constraints of the
// SMTP protocol. If the text must contain any other characters, then you must
// also specify a character set. Examples include UTF-8, ISO-8859-1, and Shift_JIS.
type Content struct {
	// The character set of the content.
	Charset *string `type:"string"`

	// The textual data of the content.
	Data *string `type:"string" required:"true"`

	metadataContent `json:"-" xml:"-"`
}

type metadataContent struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to delete an identity from the
// list of identities for the AWS Account.
type DeleteIdentityInput struct {
	// The identity to be removed from the list of identities for the AWS Account.
	Identity *string `type:"string" required:"true"`

	metadataDeleteIdentityInput `json:"-" xml:"-"`
}

type metadataDeleteIdentityInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An empty element. Receiving this element indicates that the request completed
// successfully.
type DeleteIdentityOutput struct {
	metadataDeleteIdentityOutput `json:"-" xml:"-"`
}

type metadataDeleteIdentityOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to delete an address from the
// list of verified email addresses.
type DeleteVerifiedEmailAddressInput struct {
	// An email address to be removed from the list of verified addresses.
	EmailAddress *string `type:"string" required:"true"`

	metadataDeleteVerifiedEmailAddressInput `json:"-" xml:"-"`
}

type metadataDeleteVerifiedEmailAddressInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type DeleteVerifiedEmailAddressOutput struct {
	metadataDeleteVerifiedEmailAddressOutput `json:"-" xml:"-"`
}

type metadataDeleteVerifiedEmailAddressOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the destination of the message, consisting of To:, CC:, and BCC:
// fields.
//
//  By default, the string must be 7-bit ASCII. If the text must contain any
// other characters, then you must use MIME encoded-word syntax (RFC 2047) instead
// of a literal string. MIME encoded-word syntax uses the following form: =?charset?encoding?encoded-text?=.
// For more information, see RFC 2047 (http://tools.ietf.org/html/rfc2047).
type Destination struct {
	// The BCC: field(s) of the message.
	BCCAddresses []*string `locationName:"BccAddresses" type:"list"`

	// The CC: field(s) of the message.
	CCAddresses []*string `locationName:"CcAddresses" type:"list"`

	// The To: field(s) of the message.
	ToAddresses []*string `type:"list"`

	metadataDestination `json:"-" xml:"-"`
}

type metadataDestination struct {
	SDKShapeTraits bool `type:"structure"`
}

// Given a list of verified identities, describes their DKIM attributes. The
// DKIM attributes of an email address identity includes whether DKIM signing
// is individually enabled or disabled for that address. The DKIM attributes
// of a domain name identity includes whether DKIM signing is enabled, as well
// as the DNS records (tokens) that must remain published in the domain name's
// DNS.
type GetIdentityDKIMAttributesInput struct {
	// A list of one or more verified identities - email addresses, domains, or
	// both.
	Identities []*string `type:"list" required:"true"`

	metadataGetIdentityDKIMAttributesInput `json:"-" xml:"-"`
}

type metadataGetIdentityDKIMAttributesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a list of all the DKIM attributes for the specified identity.
type GetIdentityDKIMAttributesOutput struct {
	// The DKIM attributes for an email address or a domain.
	DKIMAttributes map[string]*IdentityDKIMAttributes `locationName:"DkimAttributes" type:"map" required:"true"`

	metadataGetIdentityDKIMAttributesOutput `json:"-" xml:"-"`
}

type metadataGetIdentityDKIMAttributesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type GetIdentityNotificationAttributesInput struct {
	// A list of one or more identities.
	Identities []*string `type:"list" required:"true"`

	metadataGetIdentityNotificationAttributesInput `json:"-" xml:"-"`
}

type metadataGetIdentityNotificationAttributesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Describes whether an identity has Amazon Simple Notification Service (Amazon
// SNS) topics set for bounce, complaint, and/or delivery notifications, and
// specifies whether feedback forwarding is enabled for bounce and complaint
// notifications.
type GetIdentityNotificationAttributesOutput struct {
	// A map of Identity to IdentityNotificationAttributes.
	NotificationAttributes map[string]*IdentityNotificationAttributes `type:"map" required:"true"`

	metadataGetIdentityNotificationAttributesOutput `json:"-" xml:"-"`
}

type metadataGetIdentityNotificationAttributesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to provide the verification
// attributes for a list of identities.
type GetIdentityVerificationAttributesInput struct {
	// A list of identities.
	Identities []*string `type:"list" required:"true"`

	metadataGetIdentityVerificationAttributesInput `json:"-" xml:"-"`
}

type metadataGetIdentityVerificationAttributesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the verification attributes for a list of identities.
type GetIdentityVerificationAttributesOutput struct {
	// A map of Identities to IdentityVerificationAttributes objects.
	VerificationAttributes map[string]*IdentityVerificationAttributes `type:"map" required:"true"`

	metadataGetIdentityVerificationAttributesOutput `json:"-" xml:"-"`
}

type metadataGetIdentityVerificationAttributesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type GetSendQuotaInput struct {
	metadataGetSendQuotaInput `json:"-" xml:"-"`
}

type metadataGetSendQuotaInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the user's current activity limits returned from a successful
// GetSendQuota request.
type GetSendQuotaOutput struct {
	// The maximum number of emails the user is allowed to send in a 24-hour interval.
	// A value of -1 signifies an unlimited quota.
	Max24HourSend *float64 `type:"double"`

	// The maximum number of emails that Amazon SES can accept from the user's account
	// per second.
	//
	// The rate at which Amazon SES accepts the user's messages might be less than
	// the maximum send rate.
	MaxSendRate *float64 `type:"double"`

	// The number of emails sent during the previous 24 hours.
	SentLast24Hours *float64 `type:"double"`

	metadataGetSendQuotaOutput `json:"-" xml:"-"`
}

type metadataGetSendQuotaOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type GetSendStatisticsInput struct {
	metadataGetSendStatisticsInput `json:"-" xml:"-"`
}

type metadataGetSendStatisticsInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a list of SendDataPoint items returned from a successful GetSendStatistics
// request. This list contains aggregated data from the previous two weeks of
// sending activity.
type GetSendStatisticsOutput struct {
	// A list of data points, each of which represents 15 minutes of activity.
	SendDataPoints []*SendDataPoint `type:"list"`

	metadataGetSendStatisticsOutput `json:"-" xml:"-"`
}

type metadataGetSendStatisticsOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the DKIM attributes of a verified email address or a domain.
type IdentityDKIMAttributes struct {
	// True if DKIM signing is enabled for email sent from the identity; false otherwise.
	DKIMEnabled *bool `locationName:"DkimEnabled" type:"boolean" required:"true"`

	// A set of character strings that represent the domain's identity. Using these
	// tokens, you will need to create DNS CNAME records that point to DKIM public
	// keys hosted by Amazon SES. Amazon Web Services will eventually detect that
	// you have updated your DNS records; this detection process may take up to
	// 72 hours. Upon successful detection, Amazon SES will be able to DKIM-sign
	// email originating from that domain. (This only applies to domain identities,
	// not email address identities.)
	//
	// For more information about creating DNS records using DKIM tokens, go to
	// the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
	DKIMTokens []*string `locationName:"DkimTokens" type:"list"`

	// Describes whether Amazon SES has successfully verified the DKIM DNS records
	// (tokens) published in the domain name's DNS. (This only applies to domain
	// identities, not email address identities.)
	DKIMVerificationStatus *string `locationName:"DkimVerificationStatus" type:"string" required:"true"`

	metadataIdentityDKIMAttributes `json:"-" xml:"-"`
}

type metadataIdentityDKIMAttributes struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the notification attributes of an identity, including whether
// an identity has Amazon Simple Notification Service (Amazon SNS) topics set
// for bounce, complaint, and/or delivery notifications, and whether feedback
// forwarding is enabled for bounce and complaint notifications.
type IdentityNotificationAttributes struct {
	// The Amazon Resource Name (ARN) of the Amazon SNS topic where Amazon SES will
	// publish bounce notifications.
	BounceTopic *string `type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the Amazon SNS topic where Amazon SES will
	// publish complaint notifications.
	ComplaintTopic *string `type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the Amazon SNS topic where Amazon SES will
	// publish delivery notifications.
	DeliveryTopic *string `type:"string" required:"true"`

	// Describes whether Amazon SES will forward bounce and complaint notifications
	// as email. true indicates that Amazon SES will forward bounce and complaint
	// notifications as email, while false indicates that bounce and complaint notifications
	// will be published only to the specified bounce and complaint Amazon SNS topics.
	ForwardingEnabled *bool `type:"boolean" required:"true"`

	metadataIdentityNotificationAttributes `json:"-" xml:"-"`
}

type metadataIdentityNotificationAttributes struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the verification attributes of a single identity.
type IdentityVerificationAttributes struct {
	// The verification status of the identity: "Pending", "Success", "Failed",
	// or "TemporaryFailure".
	VerificationStatus *string `type:"string" required:"true"`

	// The verification token for a domain identity. Null for email address identities.
	VerificationToken *string `type:"string"`

	metadataIdentityVerificationAttributes `json:"-" xml:"-"`
}

type metadataIdentityVerificationAttributes struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to list all identities for the
// AWS Account.
type ListIdentitiesInput struct {
	// The type of the identities to list. Possible values are "EmailAddress" and
	// "Domain". If this parameter is omitted, then all identities will be listed.
	IdentityType *string `type:"string"`

	// The maximum number of identities per page. Possible values are 1-1000 inclusive.
	MaxItems *int64 `type:"integer"`

	// The token to use for pagination.
	NextToken *string `type:"string"`

	metadataListIdentitiesInput `json:"-" xml:"-"`
}

type metadataListIdentitiesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a list of all verified identities for the AWS Account.
type ListIdentitiesOutput struct {
	// A list of identities.
	Identities []*string `type:"list" required:"true"`

	// The token used for pagination.
	NextToken *string `type:"string"`

	metadataListIdentitiesOutput `json:"-" xml:"-"`
}

type metadataListIdentitiesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type ListVerifiedEmailAddressesInput struct {
	metadataListVerifiedEmailAddressesInput `json:"-" xml:"-"`
}

type metadataListVerifiedEmailAddressesInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a list of all the email addresses verified for the current user.
type ListVerifiedEmailAddressesOutput struct {
	// A list of email addresses that have been verified.
	VerifiedEmailAddresses []*string `type:"list"`

	metadataListVerifiedEmailAddressesOutput `json:"-" xml:"-"`
}

type metadataListVerifiedEmailAddressesOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the message to be sent, composed of a subject and a body.
type Message struct {
	// The message body.
	Body *Body `type:"structure" required:"true"`

	// The subject of the message: A short summary of the content, which will appear
	// in the recipient's inbox.
	Subject *Content `type:"structure" required:"true"`

	metadataMessage `json:"-" xml:"-"`
}

type metadataMessage struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the raw data of the message.
type RawMessage struct {
	// The raw data of the message. The client must ensure that the message format
	// complies with Internet email standards regarding email header fields, MIME
	// types, MIME encoding, and base64 encoding (if necessary).
	//
	// The To:, CC:, and BCC: headers in the raw message can contain a group list.
	//
	// For more information, go to the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/send-email-raw.html).
	Data []byte `type:"blob" required:"true"`

	metadataRawMessage `json:"-" xml:"-"`
}

type metadataRawMessage struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents sending statistics data. Each SendDataPoint contains statistics
// for a 15-minute period of sending activity.
type SendDataPoint struct {
	// Number of emails that have bounced.
	Bounces *int64 `type:"long"`

	// Number of unwanted emails that were rejected by recipients.
	Complaints *int64 `type:"long"`

	// Number of emails that have been enqueued for sending.
	DeliveryAttempts *int64 `type:"long"`

	// Number of emails rejected by Amazon SES.
	Rejects *int64 `type:"long"`

	// Time of the data point.
	Timestamp *time.Time `type:"timestamp" timestampFormat:"iso8601"`

	metadataSendDataPoint `json:"-" xml:"-"`
}

type metadataSendDataPoint struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to send a single email message.
//
// This datatype can be used in application code to compose a message consisting
// of source, destination, message, reply-to, and return-path parts. This object
// can then be sent using the SendEmail action.
type SendEmailInput struct {
	// The destination for this email, composed of To:, CC:, and BCC: fields.
	Destination *Destination `type:"structure" required:"true"`

	// The message to be sent.
	Message *Message `type:"structure" required:"true"`

	// The reply-to email address(es) for the message. If the recipient replies
	// to the message, each reply-to address will receive the reply.
	ReplyToAddresses []*string `type:"list"`

	// The email address to which bounces and complaints are to be forwarded when
	// feedback forwarding is enabled. If the message cannot be delivered to the
	// recipient, then an error message will be returned from the recipient's ISP;
	// this message will then be forwarded to the email address specified by the
	// ReturnPath parameter. The ReturnPath parameter is never overwritten. This
	// email address must be either individually verified with Amazon SES, or from
	// a domain that has been verified with Amazon SES.
	ReturnPath *string `type:"string"`

	// The identity's email address.
	//
	//  By default, the string must be 7-bit ASCII. If the text must contain any
	// other characters, then you must use MIME encoded-word syntax (RFC 2047) instead
	// of a literal string. MIME encoded-word syntax uses the following form: =?charset?encoding?encoded-text?=.
	// For more information, see RFC 2047 (http://tools.ietf.org/html/rfc2047).
	Source *string `type:"string" required:"true"`

	metadataSendEmailInput `json:"-" xml:"-"`
}

type metadataSendEmailInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a unique message ID returned from a successful SendEmail request.
type SendEmailOutput struct {
	// The unique message identifier returned from the SendEmail action.
	MessageID *string `locationName:"MessageId" type:"string" required:"true"`

	metadataSendEmailOutput `json:"-" xml:"-"`
}

type metadataSendEmailOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to send a raw email message.
//
// This datatype can be used in application code to compose a message consisting
// of source, destination, and raw message text. This object can then be sent
// using the SendRawEmail action.
type SendRawEmailInput struct {
	// A list of destinations for the message, consisting of To:, CC:, and BCC:
	// addresses.
	Destinations []*string `type:"list"`

	// The raw text of the message. The client is responsible for ensuring the following:
	//
	//   Message must contain a header and a body, separated by a blank line. All
	// required header fields must be present. Each part of a multipart MIME message
	// must be formatted properly. MIME content types must be among those supported
	// by Amazon SES. For more information, go to the Amazon SES Developer Guide
	// (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/mime-types.html).
	// Content must be base64-encoded, if MIME requires it.
	RawMessage *RawMessage `type:"structure" required:"true"`

	// The identity's email address. If you do not provide a value for this parameter,
	// you must specify a "From" address in the raw text of the message. (You can
	// also specify both.)
	//
	//  By default, the string must be 7-bit ASCII. If the text must contain any
	// other characters, then you must use MIME encoded-word syntax (RFC 2047) instead
	// of a literal string. MIME encoded-word syntax uses the following form: =?charset?encoding?encoded-text?=.
	// For more information, see RFC 2047 (http://tools.ietf.org/html/rfc2047).
	//
	// If you specify the Source parameter and have feedback forwarding enabled,
	// then bounces and complaints will be sent to this email address. This takes
	// precedence over any Return-Path header that you might include in the raw
	// text of the message.
	Source *string `type:"string"`

	metadataSendRawEmailInput `json:"-" xml:"-"`
}

type metadataSendRawEmailInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a unique message ID returned from a successful SendRawEmail request.
type SendRawEmailOutput struct {
	// The unique message identifier returned from the SendRawEmail action.
	MessageID *string `locationName:"MessageId" type:"string" required:"true"`

	metadataSendRawEmailOutput `json:"-" xml:"-"`
}

type metadataSendRawEmailOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to enable or disable DKIM signing
// for an identity.
type SetIdentityDKIMEnabledInput struct {
	// Sets whether DKIM signing is enabled for an identity. Set to true to enable
	// DKIM signing for this identity; false to disable it.
	DKIMEnabled *bool `locationName:"DkimEnabled" type:"boolean" required:"true"`

	// The identity for which DKIM signing should be enabled or disabled.
	Identity *string `type:"string" required:"true"`

	metadataSetIdentityDKIMEnabledInput `json:"-" xml:"-"`
}

type metadataSetIdentityDKIMEnabledInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An empty element. Receiving this element indicates that the request completed
// successfully.
type SetIdentityDKIMEnabledOutput struct {
	metadataSetIdentityDKIMEnabledOutput `json:"-" xml:"-"`
}

type metadataSetIdentityDKIMEnabledOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

type SetIdentityFeedbackForwardingEnabledInput struct {
	// Sets whether Amazon SES will forward bounce and complaint notifications as
	// email. true specifies that Amazon SES will forward bounce and complaint notifications
	// as email, in addition to any Amazon SNS topic publishing otherwise specified.
	// false specifies that Amazon SES will publish bounce and complaint notifications
	// only through Amazon SNS. This value can only be set to false when Amazon
	// SNS topics are set for both Bounce and Complaint notification types.
	ForwardingEnabled *bool `type:"boolean" required:"true"`

	// The identity for which to set bounce and complaint notification forwarding.
	// Examples: user@example.com, example.com.
	Identity *string `type:"string" required:"true"`

	metadataSetIdentityFeedbackForwardingEnabledInput `json:"-" xml:"-"`
}

type metadataSetIdentityFeedbackForwardingEnabledInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An empty element. Receiving this element indicates that the request completed
// successfully.
type SetIdentityFeedbackForwardingEnabledOutput struct {
	metadataSetIdentityFeedbackForwardingEnabledOutput `json:"-" xml:"-"`
}

type metadataSetIdentityFeedbackForwardingEnabledOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request to set or clear an identity's notification topic.
type SetIdentityNotificationTopicInput struct {
	// The identity for which the Amazon SNS topic will be set. Examples: user@example.com,
	// example.com.
	Identity *string `type:"string" required:"true"`

	// The type of notifications that will be published to the specified Amazon
	// SNS topic.
	NotificationType *string `type:"string" required:"true"`

	// The Amazon Resource Name (ARN) of the Amazon SNS topic. If the parameter
	// is omitted from the request or a null value is passed, SnsTopic is cleared
	// and publishing is disabled.
	SNSTopic *string `locationName:"SnsTopic" type:"string"`

	metadataSetIdentityNotificationTopicInput `json:"-" xml:"-"`
}

type metadataSetIdentityNotificationTopicInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An empty element. Receiving this element indicates that the request completed
// successfully.
type SetIdentityNotificationTopicOutput struct {
	metadataSetIdentityNotificationTopicOutput `json:"-" xml:"-"`
}

type metadataSetIdentityNotificationTopicOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to begin DKIM verification for
// a domain.
type VerifyDomainDKIMInput struct {
	// The name of the domain to be verified for Easy DKIM signing.
	Domain *string `type:"string" required:"true"`

	metadataVerifyDomainDKIMInput `json:"-" xml:"-"`
}

type metadataVerifyDomainDKIMInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents the DNS records that must be published in the domain name's DNS
// to complete DKIM setup.
type VerifyDomainDKIMOutput struct {
	// A set of character strings that represent the domain's identity. If the identity
	// is an email address, the tokens represent the domain of that address.
	//
	// Using these tokens, you will need to create DNS CNAME records that point
	// to DKIM public keys hosted by Amazon SES. Amazon Web Services will eventually
	// detect that you have updated your DNS records; this detection process may
	// take up to 72 hours. Upon successful detection, Amazon SES will be able to
	// DKIM-sign emails originating from that domain.
	//
	// For more information about creating DNS records using DKIM tokens, go to
	// the Amazon SES Developer Guide (http://docs.aws.amazon.com/ses/latest/DeveloperGuide/easy-dkim-dns-records.html).
	DKIMTokens []*string `locationName:"DkimTokens" type:"list" required:"true"`

	metadataVerifyDomainDKIMOutput `json:"-" xml:"-"`
}

type metadataVerifyDomainDKIMOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to begin domain verification.
type VerifyDomainIdentityInput struct {
	// The domain to be verified.
	Domain *string `type:"string" required:"true"`

	metadataVerifyDomainIdentityInput `json:"-" xml:"-"`
}

type metadataVerifyDomainIdentityInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a token used for domain ownership verification.
type VerifyDomainIdentityOutput struct {
	// A TXT record that must be placed in the DNS settings for the domain, in order
	// to complete domain verification.
	VerificationToken *string `type:"string" required:"true"`

	metadataVerifyDomainIdentityOutput `json:"-" xml:"-"`
}

type metadataVerifyDomainIdentityOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to begin email address verification.
type VerifyEmailAddressInput struct {
	// The email address to be verified.
	EmailAddress *string `type:"string" required:"true"`

	metadataVerifyEmailAddressInput `json:"-" xml:"-"`
}

type metadataVerifyEmailAddressInput struct {
	SDKShapeTraits bool `type:"structure"`
}

type VerifyEmailAddressOutput struct {
	metadataVerifyEmailAddressOutput `json:"-" xml:"-"`
}

type metadataVerifyEmailAddressOutput struct {
	SDKShapeTraits bool `type:"structure"`
}

// Represents a request instructing the service to begin email address verification.
type VerifyEmailIdentityInput struct {
	// The email address to be verified.
	EmailAddress *string `type:"string" required:"true"`

	metadataVerifyEmailIdentityInput `json:"-" xml:"-"`
}

type metadataVerifyEmailIdentityInput struct {
	SDKShapeTraits bool `type:"structure"`
}

// An empty element. Receiving this element indicates that the request completed
// successfully.
type VerifyEmailIdentityOutput struct {
	metadataVerifyEmailIdentityOutput `json:"-" xml:"-"`
}

type metadataVerifyEmailIdentityOutput struct {
	SDKShapeTraits bool `type:"structure"`
}