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

package connectcampaignsv2

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

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 validateOpDeleteCampaignChannelSubtypeConfig struct {
}

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

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

type validateOpDeleteCampaignCommunicationLimits struct {
}

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

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

type validateOpDeleteCampaignCommunicationTime struct {
}

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

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

type validateOpDeleteCampaignEntryLimits struct {
}

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

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

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

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

type validateOpDeleteConnectInstanceIntegration struct {
}

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

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

type validateOpDeleteInstanceOnboardingJob struct {
}

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

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

type validateOpDescribeCampaign struct {
}

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

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

type validateOpGetCampaignStateBatch struct {
}

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

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

type validateOpGetCampaignState struct {
}

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

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

type validateOpGetConnectInstanceConfig struct {
}

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

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

type validateOpGetInstanceCommunicationLimits struct {
}

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

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

type validateOpGetInstanceOnboardingJobStatus struct {
}

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

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

type validateOpListCampaigns struct {
}

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

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

type validateOpListConnectInstanceIntegrations struct {
}

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

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

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

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

type validateOpPutConnectInstanceIntegration struct {
}

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

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

type validateOpPutInstanceCommunicationLimits struct {
}

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

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

type validateOpPutOutboundRequestBatch struct {
}

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

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

type validateOpPutProfileOutboundRequestBatch struct {
}

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

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

type validateOpResumeCampaign struct {
}

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

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

type validateOpStartCampaign struct {
}

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

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

type validateOpStartInstanceOnboardingJob struct {
}

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

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

type validateOpStopCampaign struct {
}

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

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

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

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

type validateOpUpdateCampaignCommunicationLimits struct {
}

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

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

type validateOpUpdateCampaignCommunicationTime struct {
}

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

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

type validateOpUpdateCampaignEntryLimits struct {
}

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

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

type validateOpUpdateCampaignFlowAssociation struct {
}

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

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

type validateOpUpdateCampaignName struct {
}

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

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

type validateOpUpdateCampaignSchedule struct {
}

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

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

type validateOpUpdateCampaignSource struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopCampaignValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopCampaign{}, 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 addOpUpdateCampaignChannelSubtypeConfigValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCampaignChannelSubtypeConfig{}, middleware.After)
}

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

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

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

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

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

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

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

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

func validateCampaignFilters(v *types.CampaignFilters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CampaignFilters"}
	if v.InstanceIdFilter != nil {
		if err := validateInstanceIdFilter(v.InstanceIdFilter); err != nil {
			invalidParams.AddNested("InstanceIdFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChannelSubtypeConfig(v *types.ChannelSubtypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChannelSubtypeConfig"}
	if v.Telephony != nil {
		if err := validateTelephonyChannelSubtypeConfig(v.Telephony); err != nil {
			invalidParams.AddNested("Telephony", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sms != nil {
		if err := validateSmsChannelSubtypeConfig(v.Sms); err != nil {
			invalidParams.AddNested("Sms", err.(smithy.InvalidParamsError))
		}
	}
	if v.Email != nil {
		if err := validateEmailChannelSubtypeConfig(v.Email); err != nil {
			invalidParams.AddNested("Email", err.(smithy.InvalidParamsError))
		}
	}
	if v.WhatsApp != nil {
		if err := validateWhatsAppChannelSubtypeConfig(v.WhatsApp); err != nil {
			invalidParams.AddNested("WhatsApp", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChannelSubtypeParameters(v types.ChannelSubtypeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChannelSubtypeParameters"}
	switch uv := v.(type) {
	case *types.ChannelSubtypeParametersMemberEmail:
		if err := validateEmailChannelSubtypeParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[email]", err.(smithy.InvalidParamsError))
		}

	case *types.ChannelSubtypeParametersMemberSms:
		if err := validateSmsChannelSubtypeParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[sms]", err.(smithy.InvalidParamsError))
		}

	case *types.ChannelSubtypeParametersMemberTelephony:
		if err := validateTelephonyChannelSubtypeParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[telephony]", err.(smithy.InvalidParamsError))
		}

	case *types.ChannelSubtypeParametersMemberWhatsApp:
		if err := validateWhatsAppChannelSubtypeParameters(&uv.Value); err != nil {
			invalidParams.AddNested("[whatsApp]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCommunicationLimit(v *types.CommunicationLimit) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CommunicationLimit"}
	if v.MaxCountPerRecipient == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxCountPerRecipient"))
	}
	if v.Frequency == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Frequency"))
	}
	if len(v.Unit) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Unit"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateCommunicationLimits(v types.CommunicationLimits) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CommunicationLimits"}
	switch uv := v.(type) {
	case *types.CommunicationLimitsMemberCommunicationLimitsList:
		if err := validateCommunicationLimitList(uv.Value); err != nil {
			invalidParams.AddNested("[communicationLimitsList]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCommunicationLimitsConfig(v *types.CommunicationLimitsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CommunicationLimitsConfig"}
	if v.AllChannelSubtypes != nil {
		if err := validateCommunicationLimits(v.AllChannelSubtypes); err != nil {
			invalidParams.AddNested("AllChannelSubtypes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCommunicationTimeConfig(v *types.CommunicationTimeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CommunicationTimeConfig"}
	if v.LocalTimeZoneConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LocalTimeZoneConfig"))
	}
	if v.Telephony != nil {
		if err := validateTimeWindow(v.Telephony); err != nil {
			invalidParams.AddNested("Telephony", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sms != nil {
		if err := validateTimeWindow(v.Sms); err != nil {
			invalidParams.AddNested("Sms", err.(smithy.InvalidParamsError))
		}
	}
	if v.Email != nil {
		if err := validateTimeWindow(v.Email); err != nil {
			invalidParams.AddNested("Email", err.(smithy.InvalidParamsError))
		}
	}
	if v.WhatsApp != nil {
		if err := validateTimeWindow(v.WhatsApp); err != nil {
			invalidParams.AddNested("WhatsApp", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCustomerProfilesIntegrationConfig(v *types.CustomerProfilesIntegrationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CustomerProfilesIntegrationConfig"}
	if v.DomainArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainArn"))
	}
	if v.ObjectTypeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectTypeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDailyHours(v map[string][]types.TimeRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DailyHours"}
	for key := range v {
		if err := validateTimeRangeList(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEmailChannelSubtypeConfig(v *types.EmailChannelSubtypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmailChannelSubtypeConfig"}
	if v.OutboundMode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundMode"))
	}
	if v.DefaultOutboundConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundConfig"))
	} else if v.DefaultOutboundConfig != nil {
		if err := validateEmailOutboundConfig(v.DefaultOutboundConfig); err != nil {
			invalidParams.AddNested("DefaultOutboundConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEmailChannelSubtypeParameters(v *types.EmailChannelSubtypeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmailChannelSubtypeParameters"}
	if v.DestinationEmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationEmailAddress"))
	}
	if v.TemplateParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateParameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEmailOutboundConfig(v *types.EmailOutboundConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EmailOutboundConfig"}
	if v.ConnectSourceEmailAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectSourceEmailAddress"))
	}
	if v.WisdomTemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WisdomTemplateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEntryLimitsConfig(v *types.EntryLimitsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EntryLimitsConfig"}
	if v.MaxEntryCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxEntryCount"))
	}
	if v.MinEntryInterval == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinEntryInterval"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceCommunicationLimitsConfig(v *types.InstanceCommunicationLimitsConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceCommunicationLimitsConfig"}
	if v.AllChannelSubtypes != nil {
		if err := validateCommunicationLimits(v.AllChannelSubtypes); err != nil {
			invalidParams.AddNested("AllChannelSubtypes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInstanceIdFilter(v *types.InstanceIdFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InstanceIdFilter"}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if len(v.Operator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Operator"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntegrationConfig(v types.IntegrationConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegrationConfig"}
	switch uv := v.(type) {
	case *types.IntegrationConfigMemberCustomerProfiles:
		if err := validateCustomerProfilesIntegrationConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[customerProfiles]", err.(smithy.InvalidParamsError))
		}

	case *types.IntegrationConfigMemberLambda:
		if err := validateLambdaIntegrationConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[lambda]", err.(smithy.InvalidParamsError))
		}

	case *types.IntegrationConfigMemberQConnect:
		if err := validateQConnectIntegrationConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[qConnect]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateIntegrationIdentifier(v types.IntegrationIdentifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IntegrationIdentifier"}
	switch uv := v.(type) {
	case *types.IntegrationIdentifierMemberCustomerProfiles:
		if err := validateCustomerProfilesIntegrationIdentifier(&uv.Value); err != nil {
			invalidParams.AddNested("[customerProfiles]", err.(smithy.InvalidParamsError))
		}

	case *types.IntegrationIdentifierMemberLambda:
		if err := validateLambdaIntegrationIdentifier(&uv.Value); err != nil {
			invalidParams.AddNested("[lambda]", err.(smithy.InvalidParamsError))
		}

	case *types.IntegrationIdentifierMemberQConnect:
		if err := validateQConnectIntegrationIdentifier(&uv.Value); err != nil {
			invalidParams.AddNested("[qConnect]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpenHours(v types.OpenHours) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OpenHours"}
	switch uv := v.(type) {
	case *types.OpenHoursMemberDailyHours:
		if err := validateDailyHours(uv.Value); err != nil {
			invalidParams.AddNested("[dailyHours]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOutboundRequest(v *types.OutboundRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutboundRequest"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.ExpirationTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ExpirationTime"))
	}
	if v.ChannelSubtypeParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelSubtypeParameters"))
	} else if v.ChannelSubtypeParameters != nil {
		if err := validateChannelSubtypeParameters(v.ChannelSubtypeParameters); err != nil {
			invalidParams.AddNested("ChannelSubtypeParameters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePreviewConfig(v *types.PreviewConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PreviewConfig"}
	if v.BandwidthAllocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BandwidthAllocation"))
	}
	if v.TimeoutConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimeoutConfig"))
	} else if v.TimeoutConfig != nil {
		if err := validateTimeoutConfig(v.TimeoutConfig); err != nil {
			invalidParams.AddNested("TimeoutConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProfileOutboundRequest(v *types.ProfileOutboundRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProfileOutboundRequest"}
	if v.ClientToken == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClientToken"))
	}
	if v.ProfileId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateRestrictedPeriods(v types.RestrictedPeriods) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestrictedPeriods"}
	switch uv := v.(type) {
	case *types.RestrictedPeriodsMemberRestrictedPeriodList:
		if err := validateRestrictedPeriodList(uv.Value); err != nil {
			invalidParams.AddNested("[restrictedPeriodList]", err.(smithy.InvalidParamsError))
		}

	}
	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.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSmsChannelSubtypeConfig(v *types.SmsChannelSubtypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SmsChannelSubtypeConfig"}
	if v.OutboundMode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundMode"))
	}
	if v.DefaultOutboundConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundConfig"))
	} else if v.DefaultOutboundConfig != nil {
		if err := validateSmsOutboundConfig(v.DefaultOutboundConfig); err != nil {
			invalidParams.AddNested("DefaultOutboundConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSmsChannelSubtypeParameters(v *types.SmsChannelSubtypeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SmsChannelSubtypeParameters"}
	if v.DestinationPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPhoneNumber"))
	}
	if v.TemplateParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateParameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSmsOutboundConfig(v *types.SmsOutboundConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SmsOutboundConfig"}
	if v.ConnectSourcePhoneNumberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectSourcePhoneNumberArn"))
	}
	if v.WisdomTemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WisdomTemplateArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTelephonyChannelSubtypeConfig(v *types.TelephonyChannelSubtypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonyChannelSubtypeConfig"}
	if v.OutboundMode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundMode"))
	} else if v.OutboundMode != nil {
		if err := validateTelephonyOutboundMode(v.OutboundMode); err != nil {
			invalidParams.AddNested("OutboundMode", err.(smithy.InvalidParamsError))
		}
	}
	if v.DefaultOutboundConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundConfig"))
	} else if v.DefaultOutboundConfig != nil {
		if err := validateTelephonyOutboundConfig(v.DefaultOutboundConfig); err != nil {
			invalidParams.AddNested("DefaultOutboundConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTelephonyChannelSubtypeParameters(v *types.TelephonyChannelSubtypeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonyChannelSubtypeParameters"}
	if v.DestinationPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPhoneNumber"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	}
	if v.AnswerMachineDetectionConfig != nil {
		if err := validateAnswerMachineDetectionConfig(v.AnswerMachineDetectionConfig); err != nil {
			invalidParams.AddNested("AnswerMachineDetectionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTelephonyOutboundConfig(v *types.TelephonyOutboundConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonyOutboundConfig"}
	if v.ConnectContactFlowId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectContactFlowId"))
	}
	if v.AnswerMachineDetectionConfig != nil {
		if err := validateAnswerMachineDetectionConfig(v.AnswerMachineDetectionConfig); err != nil {
			invalidParams.AddNested("AnswerMachineDetectionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTelephonyOutboundMode(v types.TelephonyOutboundMode) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TelephonyOutboundMode"}
	switch uv := v.(type) {
	case *types.TelephonyOutboundModeMemberPredictive:
		if err := validatePredictiveConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[predictive]", err.(smithy.InvalidParamsError))
		}

	case *types.TelephonyOutboundModeMemberPreview:
		if err := validatePreviewConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[preview]", err.(smithy.InvalidParamsError))
		}

	case *types.TelephonyOutboundModeMemberProgressive:
		if err := validateProgressiveConfig(&uv.Value); err != nil {
			invalidParams.AddNested("[progressive]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimeRange(v *types.TimeRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeRange"}
	if v.StartTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StartTime"))
	}
	if v.EndTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimeWindow(v *types.TimeWindow) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeWindow"}
	if v.OpenHours == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OpenHours"))
	} else if v.OpenHours != nil {
		if err := validateOpenHours(v.OpenHours); err != nil {
			invalidParams.AddNested("OpenHours", err.(smithy.InvalidParamsError))
		}
	}
	if v.RestrictedPeriods != nil {
		if err := validateRestrictedPeriods(v.RestrictedPeriods); err != nil {
			invalidParams.AddNested("RestrictedPeriods", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWhatsAppChannelSubtypeConfig(v *types.WhatsAppChannelSubtypeConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WhatsAppChannelSubtypeConfig"}
	if v.OutboundMode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundMode"))
	}
	if v.DefaultOutboundConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultOutboundConfig"))
	} else if v.DefaultOutboundConfig != nil {
		if err := validateWhatsAppOutboundConfig(v.DefaultOutboundConfig); err != nil {
			invalidParams.AddNested("DefaultOutboundConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWhatsAppChannelSubtypeParameters(v *types.WhatsAppChannelSubtypeParameters) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WhatsAppChannelSubtypeParameters"}
	if v.DestinationPhoneNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationPhoneNumber"))
	}
	if v.TemplateParameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TemplateParameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateWhatsAppOutboundConfig(v *types.WhatsAppOutboundConfig) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "WhatsAppOutboundConfig"}
	if v.ConnectSourcePhoneNumberArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectSourcePhoneNumberArn"))
	}
	if v.WisdomTemplateArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("WisdomTemplateArn"))
	}
	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.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ConnectInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectInstanceId"))
	}
	if v.ChannelSubtypeConfig != nil {
		if err := validateChannelSubtypeConfig(v.ChannelSubtypeConfig); err != nil {
			invalidParams.AddNested("ChannelSubtypeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule != nil {
		if err := validateSchedule(v.Schedule); err != nil {
			invalidParams.AddNested("Schedule", err.(smithy.InvalidParamsError))
		}
	}
	if v.EntryLimitsConfig != nil {
		if err := validateEntryLimitsConfig(v.EntryLimitsConfig); err != nil {
			invalidParams.AddNested("EntryLimitsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CommunicationTimeConfig != nil {
		if err := validateCommunicationTimeConfig(v.CommunicationTimeConfig); err != nil {
			invalidParams.AddNested("CommunicationTimeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.CommunicationLimitsOverride != nil {
		if err := validateCommunicationLimitsConfig(v.CommunicationLimitsOverride); err != nil {
			invalidParams.AddNested("CommunicationLimitsOverride", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCampaignChannelSubtypeConfigInput(v *DeleteCampaignChannelSubtypeConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCampaignChannelSubtypeConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if len(v.ChannelSubtype) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelSubtype"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCampaignCommunicationLimitsInput(v *DeleteCampaignCommunicationLimitsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCampaignCommunicationLimitsInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if len(v.Config) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Config"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteCampaignCommunicationTimeInput(v *DeleteCampaignCommunicationTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteCampaignCommunicationTimeInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if len(v.Config) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Config"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteConnectInstanceIntegrationInput(v *DeleteConnectInstanceIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectInstanceIntegrationInput"}
	if v.ConnectInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectInstanceId"))
	}
	if v.IntegrationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationIdentifier"))
	} else if v.IntegrationIdentifier != nil {
		if err := validateIntegrationIdentifier(v.IntegrationIdentifier); err != nil {
			invalidParams.AddNested("IntegrationIdentifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpListCampaignsInput(v *ListCampaignsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCampaignsInput"}
	if v.Filters != nil {
		if err := validateCampaignFilters(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpPutConnectInstanceIntegrationInput(v *PutConnectInstanceIntegrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutConnectInstanceIntegrationInput"}
	if v.ConnectInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectInstanceId"))
	}
	if v.IntegrationConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IntegrationConfig"))
	} else if v.IntegrationConfig != nil {
		if err := validateIntegrationConfig(v.IntegrationConfig); err != nil {
			invalidParams.AddNested("IntegrationConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutInstanceCommunicationLimitsInput(v *PutInstanceCommunicationLimitsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutInstanceCommunicationLimitsInput"}
	if v.ConnectInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectInstanceId"))
	}
	if v.CommunicationLimitsConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommunicationLimitsConfig"))
	} else if v.CommunicationLimitsConfig != nil {
		if err := validateInstanceCommunicationLimitsConfig(v.CommunicationLimitsConfig); err != nil {
			invalidParams.AddNested("CommunicationLimitsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutOutboundRequestBatchInput(v *PutOutboundRequestBatchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutOutboundRequestBatchInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.OutboundRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutboundRequests"))
	} else if v.OutboundRequests != nil {
		if err := validateOutboundRequestList(v.OutboundRequests); err != nil {
			invalidParams.AddNested("OutboundRequests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutProfileOutboundRequestBatchInput(v *PutProfileOutboundRequestBatchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutProfileOutboundRequestBatchInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.ProfileOutboundRequests == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProfileOutboundRequests"))
	} else if v.ProfileOutboundRequests != nil {
		if err := validateProfileOutboundRequestList(v.ProfileOutboundRequests); err != nil {
			invalidParams.AddNested("ProfileOutboundRequests", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpStartInstanceOnboardingJobInput(v *StartInstanceOnboardingJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartInstanceOnboardingJobInput"}
	if v.ConnectInstanceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConnectInstanceId"))
	}
	if v.EncryptionConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EncryptionConfig"))
	} else if v.EncryptionConfig != nil {
		if err := validateEncryptionConfig(v.EncryptionConfig); err != nil {
			invalidParams.AddNested("EncryptionConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopCampaignInput(v *StopCampaignInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopCampaignInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.Tags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tags"))
	}
	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.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignChannelSubtypeConfigInput(v *UpdateCampaignChannelSubtypeConfigInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignChannelSubtypeConfigInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.ChannelSubtypeConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelSubtypeConfig"))
	} else if v.ChannelSubtypeConfig != nil {
		if err := validateChannelSubtypeConfig(v.ChannelSubtypeConfig); err != nil {
			invalidParams.AddNested("ChannelSubtypeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignCommunicationLimitsInput(v *UpdateCampaignCommunicationLimitsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignCommunicationLimitsInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.CommunicationLimitsOverride == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommunicationLimitsOverride"))
	} else if v.CommunicationLimitsOverride != nil {
		if err := validateCommunicationLimitsConfig(v.CommunicationLimitsOverride); err != nil {
			invalidParams.AddNested("CommunicationLimitsOverride", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignCommunicationTimeInput(v *UpdateCampaignCommunicationTimeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignCommunicationTimeInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.CommunicationTimeConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CommunicationTimeConfig"))
	} else if v.CommunicationTimeConfig != nil {
		if err := validateCommunicationTimeConfig(v.CommunicationTimeConfig); err != nil {
			invalidParams.AddNested("CommunicationTimeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateCampaignEntryLimitsInput(v *UpdateCampaignEntryLimitsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignEntryLimitsInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.EntryLimitsConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntryLimitsConfig"))
	} else if v.EntryLimitsConfig != nil {
		if err := validateEntryLimitsConfig(v.EntryLimitsConfig); err != nil {
			invalidParams.AddNested("EntryLimitsConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpUpdateCampaignScheduleInput(v *UpdateCampaignScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignScheduleInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Schedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
	} else 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 validateOpUpdateCampaignSourceInput(v *UpdateCampaignSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCampaignSourceInput"}
	if v.Id == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Id"))
	}
	if v.Source == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Source"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
