validators.go

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

package sesv2

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

type validateOpBatchGetMetricData struct {
}

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

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

type validateOpCancelExportJob struct {
}

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

func (m *validateOpCancelExportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CancelExportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCancelExportJobInput(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 validateOpCreateContact struct {
}

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

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

type validateOpCreateContactList struct {
}

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

func (m *validateOpCreateContactList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateContactListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateContactListInput(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 validateOpCreateDedicatedIpPool struct {
}

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

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

type validateOpCreateDeliverabilityTestReport struct {
}

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

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

type validateOpCreateEmailIdentity struct {
}

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

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

type validateOpCreateEmailIdentityPolicy struct {
}

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

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

type validateOpCreateEmailTemplate struct {
}

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

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

type validateOpCreateExportJob struct {
}

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

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

type validateOpCreateImportJob struct {
}

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

func (m *validateOpCreateImportJob) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*CreateImportJobInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpCreateImportJobInput(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 validateOpDeleteContact struct {
}

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

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

type validateOpDeleteContactList struct {
}

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

func (m *validateOpDeleteContactList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*DeleteContactListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpDeleteContactListInput(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 validateOpDeleteDedicatedIpPool struct {
}

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

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

type validateOpDeleteEmailIdentity struct {
}

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

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

type validateOpDeleteEmailIdentityPolicy struct {
}

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

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

type validateOpDeleteEmailTemplate struct {
}

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

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

type validateOpDeleteSuppressedDestination struct {
}

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

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

type validateOpGetBlacklistReports struct {
}

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

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

type validateOpGetConfigurationSetEventDestinations struct {
}

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

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

type validateOpGetConfigurationSet struct {
}

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

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

type validateOpGetContact struct {
}

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

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

type validateOpGetContactList struct {
}

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

func (m *validateOpGetContactList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*GetContactListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpGetContactListInput(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 validateOpGetDedicatedIp struct {
}

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

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

type validateOpGetDedicatedIpPool struct {
}

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

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

type validateOpGetDeliverabilityTestReport struct {
}

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

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

type validateOpGetDomainDeliverabilityCampaign struct {
}

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

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

type validateOpGetDomainStatisticsReport struct {
}

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

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

type validateOpGetEmailIdentity struct {
}

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

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

type validateOpGetEmailIdentityPolicies struct {
}

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

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

type validateOpGetEmailTemplate struct {
}

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

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

type validateOpGetExportJob struct {
}

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

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

type validateOpGetImportJob struct {
}

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

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

type validateOpGetMessageInsights struct {
}

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

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

type validateOpGetSuppressedDestination struct {
}

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

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

type validateOpListContacts struct {
}

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

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

type validateOpListDomainDeliverabilityCampaigns struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpPutAccountDetails struct {
}

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

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

type validateOpPutAccountVdmAttributes struct {
}

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

func (m *validateOpPutAccountVdmAttributes) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*PutAccountVdmAttributesInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpPutAccountVdmAttributesInput(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 validateOpPutConfigurationSetReputationOptions struct {
}

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

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

type validateOpPutConfigurationSetSendingOptions struct {
}

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

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

type validateOpPutConfigurationSetSuppressionOptions struct {
}

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

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

type validateOpPutConfigurationSetTrackingOptions struct {
}

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

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

type validateOpPutConfigurationSetVdmOptions struct {
}

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

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

type validateOpPutDedicatedIpInPool struct {
}

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

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

type validateOpPutDedicatedIpPoolScalingAttributes struct {
}

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

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

type validateOpPutDedicatedIpWarmupAttributes struct {
}

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

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

type validateOpPutDeliverabilityDashboardOption struct {
}

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

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

type validateOpPutEmailIdentityConfigurationSetAttributes struct {
}

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

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

type validateOpPutEmailIdentityDkimAttributes struct {
}

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

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

type validateOpPutEmailIdentityDkimSigningAttributes struct {
}

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

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

type validateOpPutEmailIdentityFeedbackAttributes struct {
}

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

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

type validateOpPutEmailIdentityMailFromAttributes struct {
}

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

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

type validateOpPutSuppressedDestination struct {
}

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

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

type validateOpSendBulkEmail struct {
}

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

func (m *validateOpSendBulkEmail) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*SendBulkEmailInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpSendBulkEmailInput(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 validateOpTagResource struct {
}

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

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

type validateOpTestRenderEmailTemplate struct {
}

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

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

type validateOpUntagResource struct {
}

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

func (m *validateOpUntagResource) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UntagResourceInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUntagResourceInput(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 validateOpUpdateContact struct {
}

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

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

type validateOpUpdateContactList struct {
}

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

func (m *validateOpUpdateContactList) HandleInitialize(ctx context.Context, in middleware.InitializeInput, next middleware.InitializeHandler) (
	out middleware.InitializeOutput, metadata middleware.Metadata, err error,
) {
	input, ok := in.Parameters.(*UpdateContactListInput)
	if !ok {
		return out, metadata, fmt.Errorf("unknown input parameters type %T", in.Parameters)
	}
	if err := validateOpUpdateContactListInput(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 validateOpUpdateEmailIdentityPolicy struct {
}

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

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

type validateOpUpdateEmailTemplate struct {
}

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

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

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

func addOpCancelExportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCancelExportJob{}, 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 addOpCreateContactValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateContact{}, middleware.After)
}

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

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

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

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

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

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

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

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

func addOpCreateImportJobValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateImportJob{}, 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 addOpDeleteContactValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDeleteContact{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSendBulkEmailValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendBulkEmail{}, 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 addOpTagResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpTagResource{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

func validateBatchGetMetricDataQuery(v *types.BatchGetMetricDataQuery) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetMetricDataQuery"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if len(v.Namespace) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if len(v.Metric) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Metric"))
	}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	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 validateBulkEmailContent(v *types.BulkEmailContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BulkEmailContent"}
	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 validateBulkEmailEntry(v *types.BulkEmailEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BulkEmailEntry"}
	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 v.ReplacementHeaders != nil {
		if err := validateMessageHeaderList(v.ReplacementHeaders); err != nil {
			invalidParams.AddNested("ReplacementHeaders", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBulkEmailEntryList(v []types.BulkEmailEntry) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BulkEmailEntryList"}
	for i := range v {
		if err := validateBulkEmailEntry(&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 validateContactListDestination(v *types.ContactListDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ContactListDestination"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if len(v.ContactListImportAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListImportAction"))
	}
	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 validateEmailContent(v *types.EmailContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmailContent"}
	if v.Simple != nil {
		if err := validateMessage(v.Simple); err != nil {
			invalidParams.AddNested("Simple", err.(smithy.InvalidParamsError))
		}
	}
	if v.Raw != nil {
		if err := validateRawMessage(v.Raw); err != nil {
			invalidParams.AddNested("Raw", err.(smithy.InvalidParamsError))
		}
	}
	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 validateEventDestinationDefinition(v *types.EventDestinationDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventDestinationDefinition"}
	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 validateExportDataSource(v *types.ExportDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportDataSource"}
	if v.MetricsDataSource != nil {
		if err := validateMetricsDataSource(v.MetricsDataSource); err != nil {
			invalidParams.AddNested("MetricsDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.MessageInsightsDataSource != nil {
		if err := validateMessageInsightsDataSource(v.MessageInsightsDataSource); err != nil {
			invalidParams.AddNested("MessageInsightsDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateImportDataSource(v *types.ImportDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportDataSource"}
	if v.S3Url == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3Url"))
	}
	if len(v.DataFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateImportDestination(v *types.ImportDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportDestination"}
	if v.SuppressionListDestination != nil {
		if err := validateSuppressionListDestination(v.SuppressionListDestination); err != nil {
			invalidParams.AddNested("SuppressionListDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.ContactListDestination != nil {
		if err := validateContactListDestination(v.ContactListDestination); err != nil {
			invalidParams.AddNested("ContactListDestination", 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 validateListManagementOptions(v *types.ListManagementOptions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListManagementOptions"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	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 v.Headers != nil {
		if err := validateMessageHeaderList(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageHeader(v *types.MessageHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageHeader"}
	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 validateMessageHeaderList(v []types.MessageHeader) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageHeaderList"}
	for i := range v {
		if err := validateMessageHeader(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageInsightsDataSource(v *types.MessageInsightsDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageInsightsDataSource"}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	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 validateMetricsDataSource(v *types.MetricsDataSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetricsDataSource"}
	if v.Dimensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
	}
	if len(v.Namespace) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Namespace"))
	}
	if v.Metrics == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metrics"))
	}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	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 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 validateSuppressionListDestination(v *types.SuppressionListDestination) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SuppressionListDestination"}
	if len(v.SuppressionListImportAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SuppressionListImportAction"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTagList(v []types.Tag) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagList"}
	for i := range v {
		if err := validateTag(&v[i]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%d]", i), err.(smithy.InvalidParamsError))
		}
	}
	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.Headers != nil {
		if err := validateMessageHeaderList(v.Headers); err != nil {
			invalidParams.AddNested("Headers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopic(v *types.Topic) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Topic"}
	if v.TopicName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicName"))
	}
	if v.DisplayName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DisplayName"))
	}
	if len(v.DefaultSubscriptionStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultSubscriptionStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTopicPreference(v *types.TopicPreference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TopicPreference"}
	if v.TopicName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopicName"))
	}
	if len(v.SubscriptionStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpBatchGetMetricDataInput(v *BatchGetMetricDataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetMetricDataInput"}
	if v.Queries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Queries"))
	} else if v.Queries != nil {
		if err := validateBatchGetMetricDataQueries(v.Queries); err != nil {
			invalidParams.AddNested("Queries", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelExportJobInput(v *CancelExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelExportJobInput"}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	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.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if v.EventDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
	} else if v.EventDestination != nil {
		if err := validateEventDestinationDefinition(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.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if v.TrackingOptions != nil {
		if err := validateTrackingOptions(v.TrackingOptions); err != nil {
			invalidParams.AddNested("TrackingOptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContactInput(v *CreateContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContactInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if v.TopicPreferences != nil {
		if err := validateTopicPreferenceList(v.TopicPreferences); err != nil {
			invalidParams.AddNested("TopicPreferences", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateContactListInput(v *CreateContactListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateContactListInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if v.Topics != nil {
		if err := validateTopics(v.Topics); err != nil {
			invalidParams.AddNested("Topics", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpCreateDedicatedIpPoolInput(v *CreateDedicatedIpPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDedicatedIpPoolInput"}
	if v.PoolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDeliverabilityTestReportInput(v *CreateDeliverabilityTestReportInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDeliverabilityTestReportInput"}
	if v.FromEmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromEmailAddress"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateEmailContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEmailIdentityInput(v *CreateEmailIdentityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEmailIdentityInput"}
	if v.EmailIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEmailIdentityPolicyInput(v *CreateEmailIdentityPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEmailIdentityPolicyInput"}
	if v.EmailIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
	}
	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 validateOpCreateEmailTemplateInput(v *CreateEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.TemplateContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateExportJobInput(v *CreateExportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateExportJobInput"}
	if v.ExportDataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportDataSource"))
	} else if v.ExportDataSource != nil {
		if err := validateExportDataSource(v.ExportDataSource); err != nil {
			invalidParams.AddNested("ExportDataSource", err.(smithy.InvalidParamsError))
		}
	}
	if v.ExportDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportDestination"))
	} else if v.ExportDestination != nil {
		if err := validateExportDestination(v.ExportDestination); err != nil {
			invalidParams.AddNested("ExportDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateImportJobInput(v *CreateImportJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateImportJobInput"}
	if v.ImportDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportDestination"))
	} else if v.ImportDestination != nil {
		if err := validateImportDestination(v.ImportDestination); err != nil {
			invalidParams.AddNested("ImportDestination", err.(smithy.InvalidParamsError))
		}
	}
	if v.ImportDataSource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportDataSource"))
	} else if v.ImportDataSource != nil {
		if err := validateImportDataSource(v.ImportDataSource); err != nil {
			invalidParams.AddNested("ImportDataSource", 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 validateOpDeleteContactInput(v *DeleteContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteContactListInput(v *DeleteContactListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteContactListInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	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 validateOpDeleteDedicatedIpPoolInput(v *DeleteDedicatedIpPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDedicatedIpPoolInput"}
	if v.PoolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpGetContactListInput(v *GetContactListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetContactListInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	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 validateOpGetDedicatedIpInput(v *GetDedicatedIpInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDedicatedIpInput"}
	if v.Ip == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpListDomainDeliverabilityCampaignsInput(v *ListDomainDeliverabilityCampaignsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDomainDeliverabilityCampaignsInput"}
	if v.StartDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartDate"))
	}
	if v.EndDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndDate"))
	}
	if v.SubscribedDomain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscribedDomain"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutAccountDetailsInput(v *PutAccountDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAccountDetailsInput"}
	if len(v.MailType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MailType"))
	}
	if v.WebsiteURL == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WebsiteURL"))
	}
	if v.UseCaseDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UseCaseDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutAccountVdmAttributesInput(v *PutAccountVdmAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutAccountVdmAttributesInput"}
	if v.VdmAttributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VdmAttributes"))
	} else if v.VdmAttributes != nil {
		if err := validateVdmAttributes(v.VdmAttributes); err != nil {
			invalidParams.AddNested("VdmAttributes", err.(smithy.InvalidParamsError))
		}
	}
	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 validateOpPutConfigurationSetReputationOptionsInput(v *PutConfigurationSetReputationOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConfigurationSetReputationOptionsInput"}
	if v.ConfigurationSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpPutDedicatedIpInPoolInput(v *PutDedicatedIpInPoolInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDedicatedIpInPoolInput"}
	if v.Ip == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
	}
	if v.DestinationPoolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPoolName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutDedicatedIpPoolScalingAttributesInput(v *PutDedicatedIpPoolScalingAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDedicatedIpPoolScalingAttributesInput"}
	if v.PoolName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoolName"))
	}
	if len(v.ScalingMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ScalingMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutDedicatedIpWarmupAttributesInput(v *PutDedicatedIpWarmupAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDedicatedIpWarmupAttributesInput"}
	if v.Ip == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Ip"))
	}
	if v.WarmupPercentage == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WarmupPercentage"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutDeliverabilityDashboardOptionInput(v *PutDeliverabilityDashboardOptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutDeliverabilityDashboardOptionInput"}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpPutEmailIdentityDkimSigningAttributesInput(v *PutEmailIdentityDkimSigningAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEmailIdentityDkimSigningAttributesInput"}
	if v.EmailIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
	}
	if len(v.SigningAttributesOrigin) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SigningAttributesOrigin"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpSendBulkEmailInput(v *SendBulkEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendBulkEmailInput"}
	if v.DefaultEmailTags != nil {
		if err := validateMessageTagList(v.DefaultEmailTags); err != nil {
			invalidParams.AddNested("DefaultEmailTags", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultContent"))
	} else if v.DefaultContent != nil {
		if err := validateBulkEmailContent(v.DefaultContent); err != nil {
			invalidParams.AddNested("DefaultContent", err.(smithy.InvalidParamsError))
		}
	}
	if v.BulkEmailEntries == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BulkEmailEntries"))
	} else if v.BulkEmailEntries != nil {
		if err := validateBulkEmailEntryList(v.BulkEmailEntries); err != nil {
			invalidParams.AddNested("BulkEmailEntries", 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.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateEmailContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.EmailTags != nil {
		if err := validateMessageTagList(v.EmailTags); err != nil {
			invalidParams.AddNested("EmailTags", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListManagementOptions != nil {
		if err := validateListManagementOptions(v.ListManagementOptions); err != nil {
			invalidParams.AddNested("ListManagementOptions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTagResourceInput(v *TagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	} else if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestRenderEmailTemplateInput(v *TestRenderEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestRenderEmailTemplateInput"}
	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 validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceArn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	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.EventDestinationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestinationName"))
	}
	if v.EventDestination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventDestination"))
	} else if v.EventDestination != nil {
		if err := validateEventDestinationDefinition(v.EventDestination); err != nil {
			invalidParams.AddNested("EventDestination", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactInput(v *UpdateContactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if v.EmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailAddress"))
	}
	if v.TopicPreferences != nil {
		if err := validateTopicPreferenceList(v.TopicPreferences); err != nil {
			invalidParams.AddNested("TopicPreferences", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateContactListInput(v *UpdateContactListInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateContactListInput"}
	if v.ContactListName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContactListName"))
	}
	if v.Topics != nil {
		if err := validateTopics(v.Topics); err != nil {
			invalidParams.AddNested("Topics", err.(smithy.InvalidParamsError))
		}
	}
	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 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 validateOpUpdateEmailIdentityPolicyInput(v *UpdateEmailIdentityPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEmailIdentityPolicyInput"}
	if v.EmailIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailIdentity"))
	}
	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 validateOpUpdateEmailTemplateInput(v *UpdateEmailTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEmailTemplateInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.TemplateContent == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateContent"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}