validators.go

// Code generated by smithy-go-codegen DO NOT EDIT.

package ses

import (
	"context"
	"fmt"
	"github.com/aws/aws-sdk-go-v2/service/ses/types"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpCloneReceiptRuleSet struct {
}

func (*validateOpCloneReceiptRuleSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCloneReceiptRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CloneReceiptRuleSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCloneReceiptRuleSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateConfigurationSetEventDestination struct {
}

func (*validateOpCreateConfigurationSetEventDestination) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateConfigurationSetEventDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateConfigurationSetEventDestinationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateConfigurationSetEventDestinationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateConfigurationSet struct {
}

func (*validateOpCreateConfigurationSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateConfigurationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateConfigurationSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateConfigurationSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateConfigurationSetTrackingOptions struct {
}

func (*validateOpCreateConfigurationSetTrackingOptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateConfigurationSetTrackingOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateConfigurationSetTrackingOptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateConfigurationSetTrackingOptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateCustomVerificationEmailTemplate struct {
}

func (*validateOpCreateCustomVerificationEmailTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateCustomVerificationEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateCustomVerificationEmailTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateCustomVerificationEmailTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateReceiptFilter struct {
}

func (*validateOpCreateReceiptFilter) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateReceiptFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateReceiptFilterInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateReceiptFilterInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateReceiptRule struct {
}

func (*validateOpCreateReceiptRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateReceiptRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateReceiptRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateReceiptRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateReceiptRuleSet struct {
}

func (*validateOpCreateReceiptRuleSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateReceiptRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateReceiptRuleSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateReceiptRuleSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpCreateTemplate struct {
}

func (*validateOpCreateTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpCreateTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigurationSetEventDestination struct {
}

func (*validateOpDeleteConfigurationSetEventDestination) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigurationSetEventDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigurationSetEventDestinationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigurationSetEventDestinationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigurationSet struct {
}

func (*validateOpDeleteConfigurationSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigurationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigurationSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigurationSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteConfigurationSetTrackingOptions struct {
}

func (*validateOpDeleteConfigurationSetTrackingOptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteConfigurationSetTrackingOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteConfigurationSetTrackingOptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteConfigurationSetTrackingOptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteCustomVerificationEmailTemplate struct {
}

func (*validateOpDeleteCustomVerificationEmailTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteCustomVerificationEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteCustomVerificationEmailTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteCustomVerificationEmailTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIdentity struct {
}

func (*validateOpDeleteIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteIdentityPolicy struct {
}

func (*validateOpDeleteIdentityPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteIdentityPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteIdentityPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteIdentityPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteReceiptFilter struct {
}

func (*validateOpDeleteReceiptFilter) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteReceiptFilter) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteReceiptFilterInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteReceiptFilterInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteReceiptRule struct {
}

func (*validateOpDeleteReceiptRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteReceiptRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteReceiptRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteReceiptRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteReceiptRuleSet struct {
}

func (*validateOpDeleteReceiptRuleSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteReceiptRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteReceiptRuleSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteReceiptRuleSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteTemplate struct {
}

func (*validateOpDeleteTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDeleteVerifiedEmailAddress struct {
}

func (*validateOpDeleteVerifiedEmailAddress) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDeleteVerifiedEmailAddress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteVerifiedEmailAddressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteVerifiedEmailAddressInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeConfigurationSet struct {
}

func (*validateOpDescribeConfigurationSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeConfigurationSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeConfigurationSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeConfigurationSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeReceiptRule struct {
}

func (*validateOpDescribeReceiptRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeReceiptRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeReceiptRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeReceiptRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpDescribeReceiptRuleSet struct {
}

func (*validateOpDescribeReceiptRuleSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpDescribeReceiptRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DescribeReceiptRuleSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDescribeReceiptRuleSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetCustomVerificationEmailTemplate struct {
}

func (*validateOpGetCustomVerificationEmailTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetCustomVerificationEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetCustomVerificationEmailTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetCustomVerificationEmailTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityDkimAttributes struct {
}

func (*validateOpGetIdentityDkimAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityDkimAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityDkimAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityDkimAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityMailFromDomainAttributes struct {
}

func (*validateOpGetIdentityMailFromDomainAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityMailFromDomainAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityMailFromDomainAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityMailFromDomainAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityNotificationAttributes struct {
}

func (*validateOpGetIdentityNotificationAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityNotificationAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityNotificationAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityNotificationAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityPolicies struct {
}

func (*validateOpGetIdentityPolicies) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityPolicies) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityPoliciesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityPoliciesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetIdentityVerificationAttributes struct {
}

func (*validateOpGetIdentityVerificationAttributes) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetIdentityVerificationAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetIdentityVerificationAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetIdentityVerificationAttributesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpGetTemplate struct {
}

func (*validateOpGetTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpGetTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpListIdentityPolicies struct {
}

func (*validateOpListIdentityPolicies) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpListIdentityPolicies) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ListIdentityPoliciesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpListIdentityPoliciesInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutConfigurationSetDeliveryOptions struct {
}

func (*validateOpPutConfigurationSetDeliveryOptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutConfigurationSetDeliveryOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutConfigurationSetDeliveryOptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutConfigurationSetDeliveryOptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpPutIdentityPolicy struct {
}

func (*validateOpPutIdentityPolicy) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpPutIdentityPolicy) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutIdentityPolicyInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutIdentityPolicyInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpReorderReceiptRuleSet struct {
}

func (*validateOpReorderReceiptRuleSet) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpReorderReceiptRuleSet) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*ReorderReceiptRuleSetInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpReorderReceiptRuleSetInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendBounce struct {
}

func (*validateOpSendBounce) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendBounce) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendBounceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendBounceInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendBulkTemplatedEmail struct {
}

func (*validateOpSendBulkTemplatedEmail) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendBulkTemplatedEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendBulkTemplatedEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendBulkTemplatedEmailInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendCustomVerificationEmail struct {
}

func (*validateOpSendCustomVerificationEmail) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendCustomVerificationEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendCustomVerificationEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendCustomVerificationEmailInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendEmail struct {
}

func (*validateOpSendEmail) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendEmailInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendRawEmail struct {
}

func (*validateOpSendRawEmail) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendRawEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendRawEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendRawEmailInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSendTemplatedEmail struct {
}

func (*validateOpSendTemplatedEmail) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSendTemplatedEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendTemplatedEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendTemplatedEmailInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetIdentityDkimEnabled struct {
}

func (*validateOpSetIdentityDkimEnabled) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetIdentityDkimEnabled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetIdentityDkimEnabledInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetIdentityDkimEnabledInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetIdentityFeedbackForwardingEnabled struct {
}

func (*validateOpSetIdentityFeedbackForwardingEnabled) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetIdentityFeedbackForwardingEnabled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetIdentityFeedbackForwardingEnabledInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetIdentityFeedbackForwardingEnabledInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetIdentityHeadersInNotificationsEnabled struct {
}

func (*validateOpSetIdentityHeadersInNotificationsEnabled) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetIdentityHeadersInNotificationsEnabled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetIdentityHeadersInNotificationsEnabledInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetIdentityHeadersInNotificationsEnabledInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetIdentityMailFromDomain struct {
}

func (*validateOpSetIdentityMailFromDomain) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetIdentityMailFromDomain) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetIdentityMailFromDomainInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetIdentityMailFromDomainInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetIdentityNotificationTopic struct {
}

func (*validateOpSetIdentityNotificationTopic) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetIdentityNotificationTopic) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetIdentityNotificationTopicInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetIdentityNotificationTopicInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpSetReceiptRulePosition struct {
}

func (*validateOpSetReceiptRulePosition) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpSetReceiptRulePosition) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SetReceiptRulePositionInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSetReceiptRulePositionInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpTestRenderTemplate struct {
}

func (*validateOpTestRenderTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpTestRenderTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*TestRenderTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpTestRenderTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateConfigurationSetEventDestination struct {
}

func (*validateOpUpdateConfigurationSetEventDestination) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateConfigurationSetEventDestination) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateConfigurationSetEventDestinationInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateConfigurationSetEventDestinationInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateConfigurationSetReputationMetricsEnabled struct {
}

func (*validateOpUpdateConfigurationSetReputationMetricsEnabled) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateConfigurationSetReputationMetricsEnabled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateConfigurationSetReputationMetricsEnabledInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateConfigurationSetReputationMetricsEnabledInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateConfigurationSetSendingEnabled struct {
}

func (*validateOpUpdateConfigurationSetSendingEnabled) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateConfigurationSetSendingEnabled) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateConfigurationSetSendingEnabledInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateConfigurationSetSendingEnabledInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateConfigurationSetTrackingOptions struct {
}

func (*validateOpUpdateConfigurationSetTrackingOptions) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateConfigurationSetTrackingOptions) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateConfigurationSetTrackingOptionsInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateConfigurationSetTrackingOptionsInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateCustomVerificationEmailTemplate struct {
}

func (*validateOpUpdateCustomVerificationEmailTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateCustomVerificationEmailTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateCustomVerificationEmailTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateCustomVerificationEmailTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateReceiptRule struct {
}

func (*validateOpUpdateReceiptRule) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateReceiptRule) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateReceiptRuleInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateReceiptRuleInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpUpdateTemplate struct {
}

func (*validateOpUpdateTemplate) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpUpdateTemplate) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateTemplateInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateTemplateInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyDomainDkim struct {
}

func (*validateOpVerifyDomainDkim) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyDomainDkim) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyDomainDkimInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyDomainDkimInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyDomainIdentity struct {
}

func (*validateOpVerifyDomainIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyDomainIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyDomainIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyDomainIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyEmailAddress struct {
}

func (*validateOpVerifyEmailAddress) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyEmailAddress) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyEmailAddressInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyEmailAddressInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

type validateOpVerifyEmailIdentity struct {
}

func (*validateOpVerifyEmailIdentity) ID() string {
	return "OperationInputValidation"
}

func (m *validateOpVerifyEmailIdentity) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*VerifyEmailIdentityInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpVerifyEmailIdentityInput(input); err != nil {
		return out, metadata, err
	}
	return next.HandleInitialize(ctx, in)
}

func addOpCloneReceiptRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCloneReceiptRuleSet{}, middleware.After)
}

func addOpCreateConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateConfigurationSetEventDestination{}, middleware.After)
}

func addOpCreateConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateConfigurationSet{}, middleware.After)
}

func addOpCreateConfigurationSetTrackingOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateConfigurationSetTrackingOptions{}, middleware.After)
}

func addOpCreateCustomVerificationEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCustomVerificationEmailTemplate{}, middleware.After)
}

func addOpCreateReceiptFilterValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReceiptFilter{}, middleware.After)
}

func addOpCreateReceiptRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReceiptRule{}, middleware.After)
}

func addOpCreateReceiptRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReceiptRuleSet{}, middleware.After)
}

func addOpCreateTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateTemplate{}, middleware.After)
}

func addOpDeleteConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigurationSetEventDestination{}, middleware.After)
}

func addOpDeleteConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigurationSet{}, middleware.After)
}

func addOpDeleteConfigurationSetTrackingOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteConfigurationSetTrackingOptions{}, middleware.After)
}

func addOpDeleteCustomVerificationEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteCustomVerificationEmailTemplate{}, middleware.After)
}

func addOpDeleteIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIdentity{}, middleware.After)
}

func addOpDeleteIdentityPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteIdentityPolicy{}, middleware.After)
}

func addOpDeleteReceiptFilterValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteReceiptFilter{}, middleware.After)
}

func addOpDeleteReceiptRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteReceiptRule{}, middleware.After)
}

func addOpDeleteReceiptRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteReceiptRuleSet{}, middleware.After)
}

func addOpDeleteTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteTemplate{}, middleware.After)
}

func addOpDeleteVerifiedEmailAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteVerifiedEmailAddress{}, middleware.After)
}

func addOpDescribeConfigurationSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeConfigurationSet{}, middleware.After)
}

func addOpDescribeReceiptRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeReceiptRule{}, middleware.After)
}

func addOpDescribeReceiptRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeReceiptRuleSet{}, middleware.After)
}

func addOpGetCustomVerificationEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetCustomVerificationEmailTemplate{}, middleware.After)
}

func addOpGetIdentityDkimAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityDkimAttributes{}, middleware.After)
}

func addOpGetIdentityMailFromDomainAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityMailFromDomainAttributes{}, middleware.After)
}

func addOpGetIdentityNotificationAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityNotificationAttributes{}, middleware.After)
}

func addOpGetIdentityPoliciesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityPolicies{}, middleware.After)
}

func addOpGetIdentityVerificationAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetIdentityVerificationAttributes{}, middleware.After)
}

func addOpGetTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetTemplate{}, middleware.After)
}

func addOpListIdentityPoliciesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListIdentityPolicies{}, middleware.After)
}

func addOpPutConfigurationSetDeliveryOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConfigurationSetDeliveryOptions{}, middleware.After)
}

func addOpPutIdentityPolicyValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutIdentityPolicy{}, middleware.After)
}

func addOpReorderReceiptRuleSetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpReorderReceiptRuleSet{}, middleware.After)
}

func addOpSendBounceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendBounce{}, middleware.After)
}

func addOpSendBulkTemplatedEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendBulkTemplatedEmail{}, middleware.After)
}

func addOpSendCustomVerificationEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendCustomVerificationEmail{}, middleware.After)
}

func addOpSendEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendEmail{}, middleware.After)
}

func addOpSendRawEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendRawEmail{}, middleware.After)
}

func addOpSendTemplatedEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendTemplatedEmail{}, middleware.After)
}

func addOpSetIdentityDkimEnabledValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetIdentityDkimEnabled{}, middleware.After)
}

func addOpSetIdentityFeedbackForwardingEnabledValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetIdentityFeedbackForwardingEnabled{}, middleware.After)
}

func addOpSetIdentityHeadersInNotificationsEnabledValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetIdentityHeadersInNotificationsEnabled{}, middleware.After)
}

func addOpSetIdentityMailFromDomainValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetIdentityMailFromDomain{}, middleware.After)
}

func addOpSetIdentityNotificationTopicValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetIdentityNotificationTopic{}, middleware.After)
}

func addOpSetReceiptRulePositionValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSetReceiptRulePosition{}, middleware.After)
}

func addOpTestRenderTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTestRenderTemplate{}, middleware.After)
}

func addOpUpdateConfigurationSetEventDestinationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConfigurationSetEventDestination{}, middleware.After)
}

func addOpUpdateConfigurationSetReputationMetricsEnabledValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConfigurationSetReputationMetricsEnabled{}, middleware.After)
}

func addOpUpdateConfigurationSetSendingEnabledValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConfigurationSetSendingEnabled{}, middleware.After)
}

func addOpUpdateConfigurationSetTrackingOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateConfigurationSetTrackingOptions{}, middleware.After)
}

func addOpUpdateCustomVerificationEmailTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCustomVerificationEmailTemplate{}, middleware.After)
}

func addOpUpdateReceiptRuleValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateReceiptRule{}, middleware.After)
}

func addOpUpdateTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateTemplate{}, middleware.After)
}

func addOpVerifyDomainDkimValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyDomainDkim{}, middleware.After)
}

func addOpVerifyDomainIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyDomainIdentity{}, middleware.After)
}

func addOpVerifyEmailAddressValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyEmailAddress{}, middleware.After)
}

func addOpVerifyEmailIdentityValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpVerifyEmailIdentity{}, middleware.After)
}

func validateAddHeaderAction(v *types.AddHeaderAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddHeaderAction"}
	if v.HeaderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderName"))
	}
	if v.HeaderValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HeaderValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBody(v *types.Body) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Body"}
	if v.Text != nil {
		if err := validateContent(v.Text); err != nil {
			invalidParams.AddNested("Text", err.(smithy.InvalidParamsError))
		}
	}
	if v.Html != nil {
		if err := validateContent(v.Html); err != nil {
			invalidParams.AddNested("Html", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBounceAction(v *types.BounceAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BounceAction"}
	if v.SmtpReplyCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SmtpReplyCode"))
	}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	}
	if v.Sender == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sender"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBouncedRecipientInfo(v *types.BouncedRecipientInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BouncedRecipientInfo"}
	if v.Recipient == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Recipient"))
	}
	if v.RecipientDsnFields != nil {
		if err := validateRecipientDsnFields(v.RecipientDsnFields); err != nil {
			invalidParams.AddNested("RecipientDsnFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBouncedRecipientInfoList(v []types.BouncedRecipientInfo) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BouncedRecipientInfoList"}
	for i := range v {
		if err := validateBouncedRecipientInfo(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBulkEmailDestination(v *types.BulkEmailDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BulkEmailDestination"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if v.ReplacementTags != nil {
		if err := validateMessageTagList(v.ReplacementTags); err != nil {
			invalidParams.AddNested("ReplacementTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBulkEmailDestinationList(v []types.BulkEmailDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BulkEmailDestinationList"}
	for i := range v {
		if err := validateBulkEmailDestination(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchDestination(v *types.CloudWatchDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDestination"}
	if v.DimensionConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DimensionConfigurations"))
	} else if v.DimensionConfigurations != nil {
		if err := validateCloudWatchDimensionConfigurations(v.DimensionConfigurations); err != nil {
			invalidParams.AddNested("DimensionConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchDimensionConfiguration(v *types.CloudWatchDimensionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDimensionConfiguration"}
	if v.DimensionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DimensionName"))
	}
	if len(v.DimensionValueSource) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DimensionValueSource"))
	}
	if v.DefaultDimensionValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultDimensionValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCloudWatchDimensionConfigurations(v []types.CloudWatchDimensionConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloudWatchDimensionConfigurations"}
	for i := range v {
		if err := validateCloudWatchDimensionConfiguration(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigurationSet(v *types.ConfigurationSet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigurationSet"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateContent(v *types.Content) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Content"}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventDestination(v *types.EventDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventDestination"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.MatchingEventTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MatchingEventTypes"))
	}
	if v.KinesisFirehoseDestination != nil {
		if err := validateKinesisFirehoseDestination(v.KinesisFirehoseDestination); err != nil {
			invalidParams.AddNested("KinesisFirehoseDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.CloudWatchDestination != nil {
		if err := validateCloudWatchDestination(v.CloudWatchDestination); err != nil {
			invalidParams.AddNested("CloudWatchDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.SNSDestination != nil {
		if err := validateSNSDestination(v.SNSDestination); err != nil {
			invalidParams.AddNested("SNSDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExtensionField(v *types.ExtensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExtensionField"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExtensionFieldList(v []types.ExtensionField) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExtensionFieldList"}
	for i := range v {
		if err := validateExtensionField(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKinesisFirehoseDestination(v *types.KinesisFirehoseDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisFirehoseDestination"}
	if v.IAMRoleARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IAMRoleARN"))
	}
	if v.DeliveryStreamARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DeliveryStreamARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateLambdaAction(v *types.LambdaAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LambdaAction"}
	if v.FunctionArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FunctionArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessage(v *types.Message) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Message"}
	if v.Subject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
	} else if v.Subject != nil {
		if err := validateContent(v.Subject); err != nil {
			invalidParams.AddNested("Subject", err.(smithy.InvalidParamsError))
		}
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	} else if v.Body != nil {
		if err := validateBody(v.Body); err != nil {
			invalidParams.AddNested("Body", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageDsn(v *types.MessageDsn) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageDsn"}
	if v.ReportingMta == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportingMta"))
	}
	if v.ExtensionFields != nil {
		if err := validateExtensionFieldList(v.ExtensionFields); err != nil {
			invalidParams.AddNested("ExtensionFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageTag(v *types.MessageTag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageTag"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageTagList(v []types.MessageTag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageTagList"}
	for i := range v {
		if err := validateMessageTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRawMessage(v *types.RawMessage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RawMessage"}
	if v.Data == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Data"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReceiptAction(v *types.ReceiptAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReceiptAction"}
	if v.S3Action != nil {
		if err := validateS3Action(v.S3Action); err != nil {
			invalidParams.AddNested("S3Action", err.(smithy.InvalidParamsError))
		}
	}
	if v.BounceAction != nil {
		if err := validateBounceAction(v.BounceAction); err != nil {
			invalidParams.AddNested("BounceAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.WorkmailAction != nil {
		if err := validateWorkmailAction(v.WorkmailAction); err != nil {
			invalidParams.AddNested("WorkmailAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.LambdaAction != nil {
		if err := validateLambdaAction(v.LambdaAction); err != nil {
			invalidParams.AddNested("LambdaAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.StopAction != nil {
		if err := validateStopAction(v.StopAction); err != nil {
			invalidParams.AddNested("StopAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.AddHeaderAction != nil {
		if err := validateAddHeaderAction(v.AddHeaderAction); err != nil {
			invalidParams.AddNested("AddHeaderAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.SNSAction != nil {
		if err := validateSNSAction(v.SNSAction); err != nil {
			invalidParams.AddNested("SNSAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReceiptActionsList(v []types.ReceiptAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReceiptActionsList"}
	for i := range v {
		if err := validateReceiptAction(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReceiptFilter(v *types.ReceiptFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReceiptFilter"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.IpFilter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IpFilter"))
	} else if v.IpFilter != nil {
		if err := validateReceiptIpFilter(v.IpFilter); err != nil {
			invalidParams.AddNested("IpFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReceiptIpFilter(v *types.ReceiptIpFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReceiptIpFilter"}
	if len(v.Policy) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
	}
	if v.Cidr == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cidr"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateReceiptRule(v *types.ReceiptRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReceiptRule"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Actions != nil {
		if err := validateReceiptActionsList(v.Actions); err != nil {
			invalidParams.AddNested("Actions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecipientDsnFields(v *types.RecipientDsnFields) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecipientDsnFields"}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Status == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if v.ExtensionFields != nil {
		if err := validateExtensionFieldList(v.ExtensionFields); err != nil {
			invalidParams.AddNested("ExtensionFields", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateS3Action(v *types.S3Action) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3Action"}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSNSAction(v *types.SNSAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SNSAction"}
	if v.TopicArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSNSDestination(v *types.SNSDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SNSDestination"}
	if v.TopicARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicARN"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStopAction(v *types.StopAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopAction"}
	if len(v.Scope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTemplate(v *types.Template) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Template"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWorkmailAction(v *types.WorkmailAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WorkmailAction"}
	if v.OrganizationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrganizationArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCloneReceiptRuleSetInput(v *CloneReceiptRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CloneReceiptRuleSetInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.OriginalRuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginalRuleSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfigurationSetEventDestinationInput(v *CreateConfigurationSetEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfigurationSetEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
	} else if v.EventDestination != nil {
		if err := validateEventDestination(v.EventDestination); err != nil {
			invalidParams.AddNested("EventDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfigurationSetInput(v *CreateConfigurationSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfigurationSetInput"}
	if v.ConfigurationSet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSet"))
	} else if v.ConfigurationSet != nil {
		if err := validateConfigurationSet(v.ConfigurationSet); err != nil {
			invalidParams.AddNested("ConfigurationSet", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConfigurationSetTrackingOptionsInput(v *CreateConfigurationSetTrackingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConfigurationSetTrackingOptionsInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.TrackingOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackingOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCustomVerificationEmailTemplateInput(v *CreateCustomVerificationEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCustomVerificationEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.FromEmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromEmailAddress"))
	}
	if v.TemplateSubject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateSubject"))
	}
	if v.TemplateContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateContent"))
	}
	if v.SuccessRedirectionURL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SuccessRedirectionURL"))
	}
	if v.FailureRedirectionURL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FailureRedirectionURL"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReceiptFilterInput(v *CreateReceiptFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReceiptFilterInput"}
	if v.Filter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Filter"))
	} else if v.Filter != nil {
		if err := validateReceiptFilter(v.Filter); err != nil {
			invalidParams.AddNested("Filter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReceiptRuleInput(v *CreateReceiptRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReceiptRuleInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.Rule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
	} else if v.Rule != nil {
		if err := validateReceiptRule(v.Rule); err != nil {
			invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReceiptRuleSetInput(v *CreateReceiptRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReceiptRuleSetInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTemplateInput(v *CreateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTemplateInput"}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	} else if v.Template != nil {
		if err := validateTemplate(v.Template); err != nil {
			invalidParams.AddNested("Template", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigurationSetEventDestinationInput(v *DeleteConfigurationSetEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationSetEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigurationSetInput(v *DeleteConfigurationSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationSetInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConfigurationSetTrackingOptionsInput(v *DeleteConfigurationSetTrackingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConfigurationSetTrackingOptionsInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCustomVerificationEmailTemplateInput(v *DeleteCustomVerificationEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCustomVerificationEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIdentityInput(v *DeleteIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteIdentityPolicyInput(v *DeleteIdentityPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteIdentityPolicyInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if v.PolicyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteReceiptFilterInput(v *DeleteReceiptFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteReceiptFilterInput"}
	if v.FilterName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteReceiptRuleInput(v *DeleteReceiptRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteReceiptRuleInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteReceiptRuleSetInput(v *DeleteReceiptRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteReceiptRuleSetInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTemplateInput(v *DeleteTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteVerifiedEmailAddressInput(v *DeleteVerifiedEmailAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteVerifiedEmailAddressInput"}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeConfigurationSetInput(v *DescribeConfigurationSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeConfigurationSetInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeReceiptRuleInput(v *DescribeReceiptRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReceiptRuleInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribeReceiptRuleSetInput(v *DescribeReceiptRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeReceiptRuleSetInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetCustomVerificationEmailTemplateInput(v *GetCustomVerificationEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetCustomVerificationEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityDkimAttributesInput(v *GetIdentityDkimAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityDkimAttributesInput"}
	if v.Identities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identities"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityMailFromDomainAttributesInput(v *GetIdentityMailFromDomainAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityMailFromDomainAttributesInput"}
	if v.Identities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identities"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityNotificationAttributesInput(v *GetIdentityNotificationAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityNotificationAttributesInput"}
	if v.Identities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identities"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityPoliciesInput(v *GetIdentityPoliciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityPoliciesInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if v.PolicyNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetIdentityVerificationAttributesInput(v *GetIdentityVerificationAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetIdentityVerificationAttributesInput"}
	if v.Identities == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identities"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTemplateInput(v *GetTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIdentityPoliciesInput(v *ListIdentityPoliciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIdentityPoliciesInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutConfigurationSetDeliveryOptionsInput(v *PutConfigurationSetDeliveryOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetDeliveryOptionsInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutIdentityPolicyInput(v *PutIdentityPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutIdentityPolicyInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if v.PolicyName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyName"))
	}
	if v.Policy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Policy"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpReorderReceiptRuleSetInput(v *ReorderReceiptRuleSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ReorderReceiptRuleSetInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.RuleNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendBounceInput(v *SendBounceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendBounceInput"}
	if v.OriginalMessageId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginalMessageId"))
	}
	if v.BounceSender == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BounceSender"))
	}
	if v.MessageDsn != nil {
		if err := validateMessageDsn(v.MessageDsn); err != nil {
			invalidParams.AddNested("MessageDsn", err.(smithy.InvalidParamsError))
		}
	}
	if v.BouncedRecipientInfoList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BouncedRecipientInfoList"))
	} else if v.BouncedRecipientInfoList != nil {
		if err := validateBouncedRecipientInfoList(v.BouncedRecipientInfoList); err != nil {
			invalidParams.AddNested("BouncedRecipientInfoList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendBulkTemplatedEmailInput(v *SendBulkTemplatedEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendBulkTemplatedEmailInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.DefaultTags != nil {
		if err := validateMessageTagList(v.DefaultTags); err != nil {
			invalidParams.AddNested("DefaultTags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	if v.Destinations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destinations"))
	} else if v.Destinations != nil {
		if err := validateBulkEmailDestinationList(v.Destinations); err != nil {
			invalidParams.AddNested("Destinations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendCustomVerificationEmailInput(v *SendCustomVerificationEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendCustomVerificationEmailInput"}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendEmailInput(v *SendEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendEmailInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if v.Message == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Message"))
	} else if v.Message != nil {
		if err := validateMessage(v.Message); err != nil {
			invalidParams.AddNested("Message", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateMessageTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendRawEmailInput(v *SendRawEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendRawEmailInput"}
	if v.RawMessage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RawMessage"))
	} else if v.RawMessage != nil {
		if err := validateRawMessage(v.RawMessage); err != nil {
			invalidParams.AddNested("RawMessage", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateMessageTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendTemplatedEmailInput(v *SendTemplatedEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendTemplatedEmailInput"}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if v.Tags != nil {
		if err := validateMessageTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	}
	if v.TemplateData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateData"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetIdentityDkimEnabledInput(v *SetIdentityDkimEnabledInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityDkimEnabledInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetIdentityFeedbackForwardingEnabledInput(v *SetIdentityFeedbackForwardingEnabledInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityFeedbackForwardingEnabledInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetIdentityHeadersInNotificationsEnabledInput(v *SetIdentityHeadersInNotificationsEnabledInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityHeadersInNotificationsEnabledInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if len(v.NotificationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NotificationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetIdentityMailFromDomainInput(v *SetIdentityMailFromDomainInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityMailFromDomainInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetIdentityNotificationTopicInput(v *SetIdentityNotificationTopicInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetIdentityNotificationTopicInput"}
	if v.Identity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identity"))
	}
	if len(v.NotificationType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NotificationType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSetReceiptRulePositionInput(v *SetReceiptRulePositionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SetReceiptRulePositionInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestRenderTemplateInput(v *TestRenderTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestRenderTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.TemplateData == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateData"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfigurationSetEventDestinationInput(v *UpdateConfigurationSetEventDestinationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationSetEventDestinationInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.EventDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
	} else if v.EventDestination != nil {
		if err := validateEventDestination(v.EventDestination); err != nil {
			invalidParams.AddNested("EventDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfigurationSetReputationMetricsEnabledInput(v *UpdateConfigurationSetReputationMetricsEnabledInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationSetReputationMetricsEnabledInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfigurationSetSendingEnabledInput(v *UpdateConfigurationSetSendingEnabledInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationSetSendingEnabledInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConfigurationSetTrackingOptionsInput(v *UpdateConfigurationSetTrackingOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConfigurationSetTrackingOptionsInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.TrackingOptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TrackingOptions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCustomVerificationEmailTemplateInput(v *UpdateCustomVerificationEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCustomVerificationEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateReceiptRuleInput(v *UpdateReceiptRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReceiptRuleInput"}
	if v.RuleSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleSetName"))
	}
	if v.Rule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rule"))
	} else if v.Rule != nil {
		if err := validateReceiptRule(v.Rule); err != nil {
			invalidParams.AddNested("Rule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTemplateInput(v *UpdateTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTemplateInput"}
	if v.Template == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Template"))
	} else if v.Template != nil {
		if err := validateTemplate(v.Template); err != nil {
			invalidParams.AddNested("Template", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyDomainDkimInput(v *VerifyDomainDkimInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyDomainDkimInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyDomainIdentityInput(v *VerifyDomainIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyDomainIdentityInput"}
	if v.Domain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Domain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyEmailAddressInput(v *VerifyEmailAddressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyEmailAddressInput"}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpVerifyEmailIdentityInput(v *VerifyEmailIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyEmailIdentityInput"}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}