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

package pinpointemail

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

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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)
}

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 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 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 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 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 addOpGetDedicatedIpValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetDedicatedIp{}, 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 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 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 addOpPutConfigurationSetTrackingOptionsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutConfigurationSetTrackingOptions{}, middleware.After)
}

func addOpPutDedicatedIpInPoolValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutDedicatedIpInPool{}, 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 addOpPutEmailIdentityDkimAttributesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpPutEmailIdentityDkimAttributes{}, 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 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 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 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 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 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 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 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 validateMessage(v *types.Message) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Message"}
	if v.Subject == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Subject"))
	} else if v.Subject != nil {
		if err := validateContent(v.Subject); err != nil {
			invalidParams.AddNested("Subject", err.(smithy.InvalidParamsError))
		}
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	} else if v.Body != nil {
		if err := validateBody(v.Body); err != nil {
			invalidParams.AddNested("Body", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 validateOpSendEmailInput(v *SendEmailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendEmailInput"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	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 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 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
	}
}