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

package pinpoint

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

type validateOpCreateApp struct {
}

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

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

type validateOpCreateCampaign struct {
}

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

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

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

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

type validateOpCreateJourney struct {
}

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

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

type validateOpCreatePushTemplate struct {
}

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

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

type validateOpCreateRecommenderConfiguration struct {
}

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

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

type validateOpCreateSegment struct {
}

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

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

type validateOpCreateSmsTemplate struct {
}

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

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

type validateOpCreateVoiceTemplate struct {
}

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

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

type validateOpDeleteAdmChannel struct {
}

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

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

type validateOpDeleteApnsChannel struct {
}

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

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

type validateOpDeleteApnsSandboxChannel struct {
}

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

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

type validateOpDeleteApnsVoipChannel struct {
}

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

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

type validateOpDeleteApnsVoipSandboxChannel struct {
}

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

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

type validateOpDeleteApp struct {
}

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

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

type validateOpDeleteBaiduChannel struct {
}

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

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

type validateOpDeleteCampaign struct {
}

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

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

type validateOpDeleteEmailChannel struct {
}

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

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

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

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

type validateOpDeleteEventStream struct {
}

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

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

type validateOpDeleteGcmChannel struct {
}

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

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

type validateOpDeleteInAppTemplate struct {
}

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

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

type validateOpDeleteJourney struct {
}

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

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

type validateOpDeletePushTemplate struct {
}

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

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

type validateOpDeleteRecommenderConfiguration struct {
}

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

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

type validateOpDeleteSegment struct {
}

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

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

type validateOpDeleteSmsChannel struct {
}

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

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

type validateOpDeleteSmsTemplate struct {
}

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

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

type validateOpDeleteUserEndpoints struct {
}

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

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

type validateOpDeleteVoiceChannel struct {
}

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

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

type validateOpDeleteVoiceTemplate struct {
}

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

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

type validateOpGetAdmChannel struct {
}

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

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

type validateOpGetApnsChannel struct {
}

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

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

type validateOpGetApnsSandboxChannel struct {
}

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

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

type validateOpGetApnsVoipChannel struct {
}

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

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

type validateOpGetApnsVoipSandboxChannel struct {
}

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

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

type validateOpGetApp struct {
}

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

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

type validateOpGetApplicationDateRangeKpi struct {
}

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

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

type validateOpGetApplicationSettings struct {
}

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

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

type validateOpGetBaiduChannel struct {
}

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

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

type validateOpGetCampaignActivities struct {
}

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

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

type validateOpGetCampaignDateRangeKpi struct {
}

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

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

type validateOpGetCampaign struct {
}

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

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

type validateOpGetCampaigns struct {
}

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

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

type validateOpGetCampaignVersion struct {
}

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

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

type validateOpGetCampaignVersions struct {
}

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

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

type validateOpGetChannels struct {
}

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

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

type validateOpGetEmailChannel struct {
}

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

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

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

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

type validateOpGetEventStream struct {
}

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

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

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

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

type validateOpGetGcmChannel struct {
}

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

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

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

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

type validateOpGetInAppMessages struct {
}

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

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

type validateOpGetInAppTemplate struct {
}

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

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

type validateOpGetJourneyDateRangeKpi struct {
}

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

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

type validateOpGetJourneyExecutionActivityMetrics struct {
}

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

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

type validateOpGetJourneyExecutionMetrics struct {
}

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

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

type validateOpGetJourney struct {
}

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

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

type validateOpGetPushTemplate struct {
}

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

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

type validateOpGetRecommenderConfiguration struct {
}

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

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

type validateOpGetSegmentExportJobs struct {
}

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

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

type validateOpGetSegmentImportJobs struct {
}

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

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

type validateOpGetSegment struct {
}

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

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

type validateOpGetSegments struct {
}

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

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

type validateOpGetSegmentVersion struct {
}

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

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

type validateOpGetSegmentVersions struct {
}

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

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

type validateOpGetSmsChannel struct {
}

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

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

type validateOpGetSmsTemplate struct {
}

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

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

type validateOpGetUserEndpoints struct {
}

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

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

type validateOpGetVoiceChannel struct {
}

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

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

type validateOpGetVoiceTemplate struct {
}

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

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

type validateOpListJourneys struct {
}

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

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

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

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

type validateOpPhoneNumberValidate struct {
}

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

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

type validateOpPutEvents struct {
}

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

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

type validateOpPutEventStream struct {
}

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

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

type validateOpRemoveAttributes struct {
}

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

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

type validateOpSendMessages struct {
}

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

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

type validateOpSendOTPMessage struct {
}

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

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

type validateOpSendUsersMessages struct {
}

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

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

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

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

type validateOpUpdateApnsChannel struct {
}

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

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

type validateOpUpdateApnsSandboxChannel struct {
}

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

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

type validateOpUpdateApnsVoipChannel struct {
}

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

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

type validateOpUpdateApnsVoipSandboxChannel struct {
}

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

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

type validateOpUpdateApplicationSettings struct {
}

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

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

type validateOpUpdateBaiduChannel struct {
}

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

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

type validateOpUpdateCampaign struct {
}

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

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

type validateOpUpdateEmailChannel struct {
}

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

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

type validateOpUpdateEndpoint struct {
}

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

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

type validateOpUpdateEndpointsBatch struct {
}

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

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

type validateOpUpdateGcmChannel struct {
}

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

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

type validateOpUpdateInAppTemplate struct {
}

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

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

type validateOpUpdateJourney struct {
}

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

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

type validateOpUpdateJourneyState struct {
}

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

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

type validateOpUpdatePushTemplate struct {
}

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

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

type validateOpUpdateRecommenderConfiguration struct {
}

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

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

type validateOpUpdateSegment struct {
}

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

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

type validateOpUpdateSmsChannel struct {
}

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

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

type validateOpUpdateSmsTemplate struct {
}

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

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

type validateOpUpdateTemplateActiveVersion struct {
}

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

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

type validateOpUpdateVoiceChannel struct {
}

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

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

type validateOpUpdateVoiceTemplate struct {
}

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

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

type validateOpVerifyOTPMessage struct {
}

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

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

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

func addOpCreateCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateCampaign{}, 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 addOpCreateInAppTemplateValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateInAppTemplate{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpSendUsersMessagesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpSendUsersMessages{}, 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 addOpUpdateAdmChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAdmChannel{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateActivity(v *types.Activity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Activity"}
	if v.ConditionalSplit != nil {
		if err := validateConditionalSplitActivity(v.ConditionalSplit); err != nil {
			invalidParams.AddNested("ConditionalSplit", err.(smithy.InvalidParamsError))
		}
	}
	if v.Holdout != nil {
		if err := validateHoldoutActivity(v.Holdout); err != nil {
			invalidParams.AddNested("Holdout", err.(smithy.InvalidParamsError))
		}
	}
	if v.MultiCondition != nil {
		if err := validateMultiConditionalSplitActivity(v.MultiCondition); err != nil {
			invalidParams.AddNested("MultiCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateADMChannelRequest(v *types.ADMChannelRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ADMChannelRequest"}
	if v.ClientId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientId"))
	}
	if v.ClientSecret == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientSecret"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBaiduChannelRequest(v *types.BaiduChannelRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BaiduChannelRequest"}
	if v.ApiKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApiKey"))
	}
	if v.SecretKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecretKey"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCampaignEventFilter(v *types.CampaignEventFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CampaignEventFilter"}
	if v.Dimensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
	} else if v.Dimensions != nil {
		if err := validateEventDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.FilterType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCampaignInAppMessage(v *types.CampaignInAppMessage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CampaignInAppMessage"}
	if v.Content != nil {
		if err := validateListOfInAppMessageContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCondition(v *types.Condition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
	if v.Conditions != nil {
		if err := validateListOfSimpleCondition(v.Conditions); err != nil {
			invalidParams.AddNested("Conditions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConditionalSplitActivity(v *types.ConditionalSplitActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConditionalSplitActivity"}
	if v.Condition != nil {
		if err := validateCondition(v.Condition); err != nil {
			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCreateRecommenderConfigurationShape(v *types.CreateRecommenderConfigurationShape) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRecommenderConfigurationShape"}
	if v.RecommendationProviderRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderRoleArn"))
	}
	if v.RecommendationProviderUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDefaultButtonConfiguration(v *types.DefaultButtonConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DefaultButtonConfiguration"}
	if len(v.ButtonAction) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ButtonAction"))
	}
	if v.Text == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Text"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateEvent(v *types.Event) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Event"}
	if v.EventType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventType"))
	}
	if v.Session != nil {
		if err := validateSession(v.Session); err != nil {
			invalidParams.AddNested("Session", err.(smithy.InvalidParamsError))
		}
	}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventCondition(v *types.EventCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventCondition"}
	if v.Dimensions != nil {
		if err := validateEventDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventDimensions(v *types.EventDimensions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventDimensions"}
	if v.Attributes != nil {
		if err := validateMapOfAttributeDimension(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.EventType != nil {
		if err := validateSetDimension(v.EventType); err != nil {
			invalidParams.AddNested("EventType", err.(smithy.InvalidParamsError))
		}
	}
	if v.Metrics != nil {
		if err := validateMapOfMetricDimension(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventFilter(v *types.EventFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventFilter"}
	if v.Dimensions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Dimensions"))
	} else if v.Dimensions != nil {
		if err := validateEventDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.FilterType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FilterType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventsBatch(v *types.EventsBatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventsBatch"}
	if v.Endpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Endpoint"))
	}
	if v.Events == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Events"))
	} else if v.Events != nil {
		if err := validateMapOfEvent(v.Events); err != nil {
			invalidParams.AddNested("Events", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventsRequest(v *types.EventsRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventsRequest"}
	if v.BatchItem == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BatchItem"))
	} else if v.BatchItem != nil {
		if err := validateMapOfEventsBatch(v.BatchItem); err != nil {
			invalidParams.AddNested("BatchItem", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEventStartCondition(v *types.EventStartCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EventStartCondition"}
	if v.EventFilter != nil {
		if err := validateEventFilter(v.EventFilter); err != nil {
			invalidParams.AddNested("EventFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateExportJobRequest(v *types.ExportJobRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportJobRequest"}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if v.S3UrlPrefix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3UrlPrefix"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateGPSPointDimension(v *types.GPSPointDimension) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GPSPointDimension"}
	if v.Coordinates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Coordinates"))
	} else if v.Coordinates != nil {
		if err := validateGPSCoordinates(v.Coordinates); err != nil {
			invalidParams.AddNested("Coordinates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateInAppMessageBodyConfig(v *types.InAppMessageBodyConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InAppMessageBodyConfig"}
	if len(v.Alignment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Alignment"))
	}
	if v.Body == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Body"))
	}
	if v.TextColor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextColor"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInAppMessageButton(v *types.InAppMessageButton) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InAppMessageButton"}
	if v.Android != nil {
		if err := validateOverrideButtonConfiguration(v.Android); err != nil {
			invalidParams.AddNested("Android", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultConfig != nil {
		if err := validateDefaultButtonConfiguration(v.DefaultConfig); err != nil {
			invalidParams.AddNested("DefaultConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.IOS != nil {
		if err := validateOverrideButtonConfiguration(v.IOS); err != nil {
			invalidParams.AddNested("IOS", err.(smithy.InvalidParamsError))
		}
	}
	if v.Web != nil {
		if err := validateOverrideButtonConfiguration(v.Web); err != nil {
			invalidParams.AddNested("Web", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInAppMessageContent(v *types.InAppMessageContent) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InAppMessageContent"}
	if v.BodyConfig != nil {
		if err := validateInAppMessageBodyConfig(v.BodyConfig); err != nil {
			invalidParams.AddNested("BodyConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.HeaderConfig != nil {
		if err := validateInAppMessageHeaderConfig(v.HeaderConfig); err != nil {
			invalidParams.AddNested("HeaderConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.PrimaryBtn != nil {
		if err := validateInAppMessageButton(v.PrimaryBtn); err != nil {
			invalidParams.AddNested("PrimaryBtn", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecondaryBtn != nil {
		if err := validateInAppMessageButton(v.SecondaryBtn); err != nil {
			invalidParams.AddNested("SecondaryBtn", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInAppMessageHeaderConfig(v *types.InAppMessageHeaderConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InAppMessageHeaderConfig"}
	if len(v.Alignment) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Alignment"))
	}
	if v.Header == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Header"))
	}
	if v.TextColor == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TextColor"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInAppTemplateRequest(v *types.InAppTemplateRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InAppTemplateRequest"}
	if v.Content != nil {
		if err := validateListOfInAppMessageContent(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateMapOfActivity(v map[string]types.Activity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MapOfActivity"}
	for key := range v {
		value := v[key]
		if err := validateActivity(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMapOfAttributeDimension(v map[string]types.AttributeDimension) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MapOfAttributeDimension"}
	for key := range v {
		value := v[key]
		if err := validateAttributeDimension(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMapOfEvent(v map[string]types.Event) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MapOfEvent"}
	for key := range v {
		value := v[key]
		if err := validateEvent(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMapOfEventsBatch(v map[string]types.EventsBatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MapOfEventsBatch"}
	for key := range v {
		value := v[key]
		if err := validateEventsBatch(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMapOfMetricDimension(v map[string]types.MetricDimension) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MapOfMetricDimension"}
	for key := range v {
		value := v[key]
		if err := validateMetricDimension(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMessageConfiguration(v *types.MessageConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MessageConfiguration"}
	if v.InAppMessage != nil {
		if err := validateCampaignInAppMessage(v.InAppMessage); err != nil {
			invalidParams.AddNested("InAppMessage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMultiConditionalBranch(v *types.MultiConditionalBranch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiConditionalBranch"}
	if v.Condition != nil {
		if err := validateSimpleCondition(v.Condition); err != nil {
			invalidParams.AddNested("Condition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMultiConditionalSplitActivity(v *types.MultiConditionalSplitActivity) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiConditionalSplitActivity"}
	if v.Branches != nil {
		if err := validateListOfMultiConditionalBranch(v.Branches); err != nil {
			invalidParams.AddNested("Branches", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRecencyDimension(v *types.RecencyDimension) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecencyDimension"}
	if len(v.Duration) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Duration"))
	}
	if len(v.RecencyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecencyType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSchedule(v *types.Schedule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Schedule"}
	if v.EventFilter != nil {
		if err := validateCampaignEventFilter(v.EventFilter); err != nil {
			invalidParams.AddNested("EventFilter", err.(smithy.InvalidParamsError))
		}
	}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentBehaviors(v *types.SegmentBehaviors) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentBehaviors"}
	if v.Recency != nil {
		if err := validateRecencyDimension(v.Recency); err != nil {
			invalidParams.AddNested("Recency", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSegmentDemographics(v *types.SegmentDemographics) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentDemographics"}
	if v.AppVersion != nil {
		if err := validateSetDimension(v.AppVersion); err != nil {
			invalidParams.AddNested("AppVersion", err.(smithy.InvalidParamsError))
		}
	}
	if v.Channel != nil {
		if err := validateSetDimension(v.Channel); err != nil {
			invalidParams.AddNested("Channel", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeviceType != nil {
		if err := validateSetDimension(v.DeviceType); err != nil {
			invalidParams.AddNested("DeviceType", err.(smithy.InvalidParamsError))
		}
	}
	if v.Make != nil {
		if err := validateSetDimension(v.Make); err != nil {
			invalidParams.AddNested("Make", err.(smithy.InvalidParamsError))
		}
	}
	if v.Model != nil {
		if err := validateSetDimension(v.Model); err != nil {
			invalidParams.AddNested("Model", err.(smithy.InvalidParamsError))
		}
	}
	if v.Platform != nil {
		if err := validateSetDimension(v.Platform); err != nil {
			invalidParams.AddNested("Platform", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentDimensions(v *types.SegmentDimensions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentDimensions"}
	if v.Attributes != nil {
		if err := validateMapOfAttributeDimension(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.Behavior != nil {
		if err := validateSegmentBehaviors(v.Behavior); err != nil {
			invalidParams.AddNested("Behavior", err.(smithy.InvalidParamsError))
		}
	}
	if v.Demographic != nil {
		if err := validateSegmentDemographics(v.Demographic); err != nil {
			invalidParams.AddNested("Demographic", err.(smithy.InvalidParamsError))
		}
	}
	if v.Location != nil {
		if err := validateSegmentLocation(v.Location); err != nil {
			invalidParams.AddNested("Location", err.(smithy.InvalidParamsError))
		}
	}
	if v.Metrics != nil {
		if err := validateMapOfMetricDimension(v.Metrics); err != nil {
			invalidParams.AddNested("Metrics", err.(smithy.InvalidParamsError))
		}
	}
	if v.UserAttributes != nil {
		if err := validateMapOfAttributeDimension(v.UserAttributes); err != nil {
			invalidParams.AddNested("UserAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentGroup(v *types.SegmentGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentGroup"}
	if v.Dimensions != nil {
		if err := validateListOfSegmentDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceSegments != nil {
		if err := validateListOfSegmentReference(v.SourceSegments); err != nil {
			invalidParams.AddNested("SourceSegments", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentGroupList(v *types.SegmentGroupList) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentGroupList"}
	if v.Groups != nil {
		if err := validateListOfSegmentGroup(v.Groups); err != nil {
			invalidParams.AddNested("Groups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSegmentLocation(v *types.SegmentLocation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SegmentLocation"}
	if v.Country != nil {
		if err := validateSetDimension(v.Country); err != nil {
			invalidParams.AddNested("Country", err.(smithy.InvalidParamsError))
		}
	}
	if v.GPSPoint != nil {
		if err := validateGPSPointDimension(v.GPSPoint); err != nil {
			invalidParams.AddNested("GPSPoint", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSendOTPMessageRequestParameters(v *types.SendOTPMessageRequestParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendOTPMessageRequestParameters"}
	if v.BrandName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BrandName"))
	}
	if v.Channel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Channel"))
	}
	if v.DestinationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationIdentity"))
	}
	if v.OriginationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginationIdentity"))
	}
	if v.ReferenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSendUsersMessageRequest(v *types.SendUsersMessageRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendUsersMessageRequest"}
	if v.MessageConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageConfiguration"))
	}
	if v.Users == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Users"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSession(v *types.Session) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Session"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.StartTimestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTimestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateSimpleCondition(v *types.SimpleCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SimpleCondition"}
	if v.EventCondition != nil {
		if err := validateEventCondition(v.EventCondition); err != nil {
			invalidParams.AddNested("EventCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.SegmentCondition != nil {
		if err := validateSegmentCondition(v.SegmentCondition); err != nil {
			invalidParams.AddNested("SegmentCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.SegmentDimensions != nil {
		if err := validateSegmentDimensions(v.SegmentDimensions); err != nil {
			invalidParams.AddNested("SegmentDimensions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStartCondition(v *types.StartCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCondition"}
	if v.EventStartCondition != nil {
		if err := validateEventStartCondition(v.EventStartCondition); err != nil {
			invalidParams.AddNested("EventStartCondition", err.(smithy.InvalidParamsError))
		}
	}
	if v.SegmentStartCondition != nil {
		if err := validateSegmentCondition(v.SegmentStartCondition); err != nil {
			invalidParams.AddNested("SegmentStartCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUpdateRecommenderConfigurationShape(v *types.UpdateRecommenderConfigurationShape) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecommenderConfigurationShape"}
	if v.RecommendationProviderRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderRoleArn"))
	}
	if v.RecommendationProviderUri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommendationProviderUri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVerifyOTPMessageRequestParameters(v *types.VerifyOTPMessageRequestParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyOTPMessageRequestParameters"}
	if v.DestinationIdentity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationIdentity"))
	}
	if v.Otp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Otp"))
	}
	if v.ReferenceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWriteCampaignRequest(v *types.WriteCampaignRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteCampaignRequest"}
	if v.AdditionalTreatments != nil {
		if err := validateListOfWriteTreatmentResource(v.AdditionalTreatments); err != nil {
			invalidParams.AddNested("AdditionalTreatments", err.(smithy.InvalidParamsError))
		}
	}
	if v.CustomDeliveryConfiguration != nil {
		if err := validateCustomDeliveryConfiguration(v.CustomDeliveryConfiguration); err != nil {
			invalidParams.AddNested("CustomDeliveryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MessageConfiguration != nil {
		if err := validateMessageConfiguration(v.MessageConfiguration); err != nil {
			invalidParams.AddNested("MessageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule != nil {
		if err := validateSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWriteEventStream(v *types.WriteEventStream) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteEventStream"}
	if v.DestinationStreamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationStreamArn"))
	}
	if v.RoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWriteJourneyRequest(v *types.WriteJourneyRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteJourneyRequest"}
	if v.Activities != nil {
		if err := validateMapOfActivity(v.Activities); err != nil {
			invalidParams.AddNested("Activities", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.StartCondition != nil {
		if err := validateStartCondition(v.StartCondition); err != nil {
			invalidParams.AddNested("StartCondition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWriteSegmentRequest(v *types.WriteSegmentRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteSegmentRequest"}
	if v.Dimensions != nil {
		if err := validateSegmentDimensions(v.Dimensions); err != nil {
			invalidParams.AddNested("Dimensions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SegmentGroups != nil {
		if err := validateSegmentGroupList(v.SegmentGroups); err != nil {
			invalidParams.AddNested("SegmentGroups", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWriteTreatmentResource(v *types.WriteTreatmentResource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WriteTreatmentResource"}
	if v.CustomDeliveryConfiguration != nil {
		if err := validateCustomDeliveryConfiguration(v.CustomDeliveryConfiguration); err != nil {
			invalidParams.AddNested("CustomDeliveryConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MessageConfiguration != nil {
		if err := validateMessageConfiguration(v.MessageConfiguration); err != nil {
			invalidParams.AddNested("MessageConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule != nil {
		if err := validateSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAppInput(v *CreateAppInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAppInput"}
	if v.CreateApplicationRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreateApplicationRequest"))
	} else if v.CreateApplicationRequest != nil {
		if err := validateCreateApplicationRequest(v.CreateApplicationRequest); err != nil {
			invalidParams.AddNested("CreateApplicationRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateCampaignInput(v *CreateCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCampaignInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WriteCampaignRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteCampaignRequest"))
	} else if v.WriteCampaignRequest != nil {
		if err := validateWriteCampaignRequest(v.WriteCampaignRequest); err != nil {
			invalidParams.AddNested("WriteCampaignRequest", err.(smithy.InvalidParamsError))
		}
	}
	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.EmailTemplateRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailTemplateRequest"))
	}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	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.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.ExportJobRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExportJobRequest"))
	} else if v.ExportJobRequest != nil {
		if err := validateExportJobRequest(v.ExportJobRequest); err != nil {
			invalidParams.AddNested("ExportJobRequest", 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.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.ImportJobRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ImportJobRequest"))
	} else if v.ImportJobRequest != nil {
		if err := validateImportJobRequest(v.ImportJobRequest); err != nil {
			invalidParams.AddNested("ImportJobRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInAppTemplateInput(v *CreateInAppTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInAppTemplateInput"}
	if v.InAppTemplateRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InAppTemplateRequest"))
	} else if v.InAppTemplateRequest != nil {
		if err := validateInAppTemplateRequest(v.InAppTemplateRequest); err != nil {
			invalidParams.AddNested("InAppTemplateRequest", err.(smithy.InvalidParamsError))
		}
	}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateJourneyInput(v *CreateJourneyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateJourneyInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WriteJourneyRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteJourneyRequest"))
	} else if v.WriteJourneyRequest != nil {
		if err := validateWriteJourneyRequest(v.WriteJourneyRequest); err != nil {
			invalidParams.AddNested("WriteJourneyRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateRecommenderConfigurationInput(v *CreateRecommenderConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRecommenderConfigurationInput"}
	if v.CreateRecommenderConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreateRecommenderConfiguration"))
	} else if v.CreateRecommenderConfiguration != nil {
		if err := validateCreateRecommenderConfigurationShape(v.CreateRecommenderConfiguration); err != nil {
			invalidParams.AddNested("CreateRecommenderConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSegmentInput(v *CreateSegmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSegmentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WriteSegmentRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteSegmentRequest"))
	} else if v.WriteSegmentRequest != nil {
		if err := validateWriteSegmentRequest(v.WriteSegmentRequest); err != nil {
			invalidParams.AddNested("WriteSegmentRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

func validateOpDeleteEmailChannelInput(v *DeleteEmailChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEmailChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	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 validateOpDeleteEndpointInput(v *DeleteEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEndpointInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDeleteJourneyInput(v *DeleteJourneyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteJourneyInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteSegmentInput(v *DeleteSegmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSegmentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteUserEndpointsInput(v *DeleteUserEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteUserEndpointsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpGetApplicationDateRangeKpiInput(v *GetApplicationDateRangeKpiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetApplicationDateRangeKpiInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.KpiName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KpiName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpGetEmailChannelInput(v *GetEmailChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEmailChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	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 validateOpGetEndpointInput(v *GetEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEndpointInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEventStreamInput(v *GetEventStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEventStreamInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	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.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetGcmChannelInput(v *GetGcmChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGcmChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	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.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetInAppMessagesInput(v *GetInAppMessagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetInAppMessagesInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetJourneyDateRangeKpiInput(v *GetJourneyDateRangeKpiInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyDateRangeKpiInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if v.KpiName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("KpiName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetJourneyExecutionActivityMetricsInput(v *GetJourneyExecutionActivityMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyExecutionActivityMetricsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyActivityId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyActivityId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetJourneyExecutionMetricsInput(v *GetJourneyExecutionMetricsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyExecutionMetricsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetJourneyInput(v *GetJourneyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJourneyInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetSegmentExportJobsInput(v *GetSegmentExportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentExportJobsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSegmentImportJobsInput(v *GetSegmentImportJobsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentImportJobsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSegmentInput(v *GetSegmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetSegmentVersionInput(v *GetSegmentVersionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentVersionInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSegmentVersionsInput(v *GetSegmentVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSegmentVersionsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpGetUserEndpointsInput(v *GetUserEndpointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserEndpointsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListJourneysInput(v *ListJourneysInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListJourneysInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	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 validateOpListTemplateVersionsInput(v *ListTemplateVersionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTemplateVersionsInput"}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if v.TemplateType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpPutEventsInput(v *PutEventsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEventsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EventsRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EventsRequest"))
	} else if v.EventsRequest != nil {
		if err := validateEventsRequest(v.EventsRequest); err != nil {
			invalidParams.AddNested("EventsRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutEventStreamInput(v *PutEventStreamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEventStreamInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WriteEventStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteEventStream"))
	} else if v.WriteEventStream != nil {
		if err := validateWriteEventStream(v.WriteEventStream); err != nil {
			invalidParams.AddNested("WriteEventStream", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveAttributesInput(v *RemoveAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveAttributesInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.AttributeType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeType"))
	}
	if v.UpdateAttributesRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateAttributesRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendMessagesInput(v *SendMessagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendMessagesInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.MessageRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MessageRequest"))
	} else if v.MessageRequest != nil {
		if err := validateMessageRequest(v.MessageRequest); err != nil {
			invalidParams.AddNested("MessageRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendOTPMessageInput(v *SendOTPMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendOTPMessageInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SendOTPMessageRequestParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SendOTPMessageRequestParameters"))
	} else if v.SendOTPMessageRequestParameters != nil {
		if err := validateSendOTPMessageRequestParameters(v.SendOTPMessageRequestParameters); err != nil {
			invalidParams.AddNested("SendOTPMessageRequestParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSendUsersMessagesInput(v *SendUsersMessagesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SendUsersMessagesInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SendUsersMessageRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SendUsersMessageRequest"))
	} else if v.SendUsersMessageRequest != nil {
		if err := validateSendUsersMessageRequest(v.SendUsersMessageRequest); err != nil {
			invalidParams.AddNested("SendUsersMessageRequest", 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.TagsModel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagsModel"))
	} else if v.TagsModel != nil {
		if err := validateTagsModel(v.TagsModel); err != nil {
			invalidParams.AddNested("TagsModel", 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 validateOpUpdateAdmChannelInput(v *UpdateAdmChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAdmChannelInput"}
	if v.ADMChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ADMChannelRequest"))
	} else if v.ADMChannelRequest != nil {
		if err := validateADMChannelRequest(v.ADMChannelRequest); err != nil {
			invalidParams.AddNested("ADMChannelRequest", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApnsChannelInput(v *UpdateApnsChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsChannelInput"}
	if v.APNSChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("APNSChannelRequest"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApnsSandboxChannelInput(v *UpdateApnsSandboxChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsSandboxChannelInput"}
	if v.APNSSandboxChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("APNSSandboxChannelRequest"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApnsVoipChannelInput(v *UpdateApnsVoipChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsVoipChannelInput"}
	if v.APNSVoipChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("APNSVoipChannelRequest"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApnsVoipSandboxChannelInput(v *UpdateApnsVoipSandboxChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApnsVoipSandboxChannelInput"}
	if v.APNSVoipSandboxChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("APNSVoipSandboxChannelRequest"))
	}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateApplicationSettingsInput(v *UpdateApplicationSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateApplicationSettingsInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.WriteApplicationSettingsRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteApplicationSettingsRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateBaiduChannelInput(v *UpdateBaiduChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBaiduChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.BaiduChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BaiduChannelRequest"))
	} else if v.BaiduChannelRequest != nil {
		if err := validateBaiduChannelRequest(v.BaiduChannelRequest); err != nil {
			invalidParams.AddNested("BaiduChannelRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignInput(v *UpdateCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.CampaignId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CampaignId"))
	}
	if v.WriteCampaignRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteCampaignRequest"))
	} else if v.WriteCampaignRequest != nil {
		if err := validateWriteCampaignRequest(v.WriteCampaignRequest); err != nil {
			invalidParams.AddNested("WriteCampaignRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEmailChannelInput(v *UpdateEmailChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEmailChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EmailChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailChannelRequest"))
	} else if v.EmailChannelRequest != nil {
		if err := validateEmailChannelRequest(v.EmailChannelRequest); err != nil {
			invalidParams.AddNested("EmailChannelRequest", err.(smithy.InvalidParamsError))
		}
	}
	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.EmailTemplateRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EmailTemplateRequest"))
	}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEndpointInput(v *UpdateEndpointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EndpointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointId"))
	}
	if v.EndpointRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEndpointsBatchInput(v *UpdateEndpointsBatchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEndpointsBatchInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.EndpointBatchRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointBatchRequest"))
	} else if v.EndpointBatchRequest != nil {
		if err := validateEndpointBatchRequest(v.EndpointBatchRequest); err != nil {
			invalidParams.AddNested("EndpointBatchRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGcmChannelInput(v *UpdateGcmChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGcmChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.GCMChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GCMChannelRequest"))
	} else if v.GCMChannelRequest != nil {
		if err := validateGCMChannelRequest(v.GCMChannelRequest); err != nil {
			invalidParams.AddNested("GCMChannelRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateInAppTemplateInput(v *UpdateInAppTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateInAppTemplateInput"}
	if v.InAppTemplateRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InAppTemplateRequest"))
	} else if v.InAppTemplateRequest != nil {
		if err := validateInAppTemplateRequest(v.InAppTemplateRequest); err != nil {
			invalidParams.AddNested("InAppTemplateRequest", err.(smithy.InvalidParamsError))
		}
	}
	if v.TemplateName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateJourneyInput(v *UpdateJourneyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateJourneyInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if v.WriteJourneyRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteJourneyRequest"))
	} else if v.WriteJourneyRequest != nil {
		if err := validateWriteJourneyRequest(v.WriteJourneyRequest); err != nil {
			invalidParams.AddNested("WriteJourneyRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateJourneyStateInput(v *UpdateJourneyStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateJourneyStateInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.JourneyId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyId"))
	}
	if v.JourneyStateRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JourneyStateRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateRecommenderConfigurationInput(v *UpdateRecommenderConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecommenderConfigurationInput"}
	if v.RecommenderId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecommenderId"))
	}
	if v.UpdateRecommenderConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateRecommenderConfiguration"))
	} else if v.UpdateRecommenderConfiguration != nil {
		if err := validateUpdateRecommenderConfigurationShape(v.UpdateRecommenderConfiguration); err != nil {
			invalidParams.AddNested("UpdateRecommenderConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSegmentInput(v *UpdateSegmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSegmentInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SegmentId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentId"))
	}
	if v.WriteSegmentRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WriteSegmentRequest"))
	} else if v.WriteSegmentRequest != nil {
		if err := validateWriteSegmentRequest(v.WriteSegmentRequest); err != nil {
			invalidParams.AddNested("WriteSegmentRequest", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSmsChannelInput(v *UpdateSmsChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSmsChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.SMSChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SMSChannelRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateVoiceChannelInput(v *UpdateVoiceChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateVoiceChannelInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.VoiceChannelRequest == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceChannelRequest"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpVerifyOTPMessageInput(v *VerifyOTPMessageInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VerifyOTPMessageInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if v.VerifyOTPMessageRequestParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VerifyOTPMessageRequestParameters"))
	} else if v.VerifyOTPMessageRequestParameters != nil {
		if err := validateVerifyOTPMessageRequestParameters(v.VerifyOTPMessageRequestParameters); err != nil {
			invalidParams.AddNested("VerifyOTPMessageRequestParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
