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

package chimesdkmediapipelines

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

type validateOpCreateMediaCapturePipeline struct {
}

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

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

type validateOpCreateMediaConcatenationPipeline struct {
}

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

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

type validateOpCreateMediaInsightsPipelineConfiguration struct {
}

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

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

type validateOpCreateMediaInsightsPipeline struct {
}

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

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

type validateOpCreateMediaLiveConnectorPipeline struct {
}

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

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

type validateOpCreateMediaPipelineKinesisVideoStreamPool struct {
}

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

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

type validateOpCreateMediaStreamPipeline struct {
}

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

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

type validateOpDeleteMediaCapturePipeline struct {
}

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

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

type validateOpDeleteMediaInsightsPipelineConfiguration struct {
}

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

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

type validateOpDeleteMediaPipeline struct {
}

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

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

type validateOpDeleteMediaPipelineKinesisVideoStreamPool struct {
}

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

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

type validateOpGetMediaCapturePipeline struct {
}

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

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

type validateOpGetMediaInsightsPipelineConfiguration struct {
}

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

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

type validateOpGetMediaPipeline struct {
}

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

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

type validateOpGetMediaPipelineKinesisVideoStreamPool struct {
}

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

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

type validateOpGetSpeakerSearchTask struct {
}

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

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

type validateOpGetVoiceToneAnalysisTask struct {
}

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

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

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

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

type validateOpStartVoiceToneAnalysisTask struct {
}

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

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

type validateOpStopSpeakerSearchTask struct {
}

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

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

type validateOpStopVoiceToneAnalysisTask struct {
}

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

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

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

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

type validateOpUpdateMediaInsightsPipelineStatus struct {
}

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

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

type validateOpUpdateMediaPipelineKinesisVideoStreamPool struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStopVoiceToneAnalysisTaskValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopVoiceToneAnalysisTask{}, 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 addOpUpdateMediaInsightsPipelineConfigurationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateMediaInsightsPipelineConfiguration{}, middleware.After)
}

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

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

func validateAmazonTranscribeCallAnalyticsProcessorConfiguration(v *types.AmazonTranscribeCallAnalyticsProcessorConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AmazonTranscribeCallAnalyticsProcessorConfiguration"}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.PostCallAnalyticsSettings != nil {
		if err := validatePostCallAnalyticsSettings(v.PostCallAnalyticsSettings); err != nil {
			invalidParams.AddNested("PostCallAnalyticsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateArtifactsConcatenationConfiguration(v *types.ArtifactsConcatenationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ArtifactsConcatenationConfiguration"}
	if v.Audio == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Audio"))
	} else if v.Audio != nil {
		if err := validateAudioConcatenationConfiguration(v.Audio); err != nil {
			invalidParams.AddNested("Audio", err.(smithy.InvalidParamsError))
		}
	}
	if v.Video == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Video"))
	} else if v.Video != nil {
		if err := validateVideoConcatenationConfiguration(v.Video); err != nil {
			invalidParams.AddNested("Video", err.(smithy.InvalidParamsError))
		}
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateContentConcatenationConfiguration(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.DataChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataChannel"))
	} else if v.DataChannel != nil {
		if err := validateDataChannelConcatenationConfiguration(v.DataChannel); err != nil {
			invalidParams.AddNested("DataChannel", err.(smithy.InvalidParamsError))
		}
	}
	if v.TranscriptionMessages == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TranscriptionMessages"))
	} else if v.TranscriptionMessages != nil {
		if err := validateTranscriptionMessagesConcatenationConfiguration(v.TranscriptionMessages); err != nil {
			invalidParams.AddNested("TranscriptionMessages", err.(smithy.InvalidParamsError))
		}
	}
	if v.MeetingEvents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MeetingEvents"))
	} else if v.MeetingEvents != nil {
		if err := validateMeetingEventsConcatenationConfiguration(v.MeetingEvents); err != nil {
			invalidParams.AddNested("MeetingEvents", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositedVideo == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CompositedVideo"))
	} else if v.CompositedVideo != nil {
		if err := validateCompositedVideoConcatenationConfiguration(v.CompositedVideo); err != nil {
			invalidParams.AddNested("CompositedVideo", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateArtifactsConfiguration(v *types.ArtifactsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ArtifactsConfiguration"}
	if v.Audio == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Audio"))
	} else if v.Audio != nil {
		if err := validateAudioArtifactsConfiguration(v.Audio); err != nil {
			invalidParams.AddNested("Audio", err.(smithy.InvalidParamsError))
		}
	}
	if v.Video == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Video"))
	} else if v.Video != nil {
		if err := validateVideoArtifactsConfiguration(v.Video); err != nil {
			invalidParams.AddNested("Video", err.(smithy.InvalidParamsError))
		}
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	} else if v.Content != nil {
		if err := validateContentArtifactsConfiguration(v.Content); err != nil {
			invalidParams.AddNested("Content", err.(smithy.InvalidParamsError))
		}
	}
	if v.CompositedVideo != nil {
		if err := validateCompositedVideoArtifactsConfiguration(v.CompositedVideo); err != nil {
			invalidParams.AddNested("CompositedVideo", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateChimeSdkMeetingConcatenationConfiguration(v *types.ChimeSdkMeetingConcatenationConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChimeSdkMeetingConcatenationConfiguration"}
	if v.ArtifactsConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ArtifactsConfiguration"))
	} else if v.ArtifactsConfiguration != nil {
		if err := validateArtifactsConcatenationConfiguration(v.ArtifactsConfiguration); err != nil {
			invalidParams.AddNested("ArtifactsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChimeSdkMeetingConfiguration(v *types.ChimeSdkMeetingConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChimeSdkMeetingConfiguration"}
	if v.ArtifactsConfiguration != nil {
		if err := validateArtifactsConfiguration(v.ArtifactsConfiguration); err != nil {
			invalidParams.AddNested("ArtifactsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateChimeSdkMeetingLiveConnectorConfiguration(v *types.ChimeSdkMeetingLiveConnectorConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ChimeSdkMeetingLiveConnectorConfiguration"}
	if v.Arn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Arn"))
	}
	if len(v.MuxType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MuxType"))
	}
	if v.CompositedVideo != nil {
		if err := validateCompositedVideoArtifactsConfiguration(v.CompositedVideo); err != nil {
			invalidParams.AddNested("CompositedVideo", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCompositedVideoArtifactsConfiguration(v *types.CompositedVideoArtifactsConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CompositedVideoArtifactsConfiguration"}
	if v.GridViewConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GridViewConfiguration"))
	} else if v.GridViewConfiguration != nil {
		if err := validateGridViewConfiguration(v.GridViewConfiguration); err != nil {
			invalidParams.AddNested("GridViewConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConcatenationSink(v *types.ConcatenationSink) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConcatenationSink"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.S3BucketSinkConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketSinkConfiguration"))
	} else if v.S3BucketSinkConfiguration != nil {
		if err := validateS3BucketSinkConfiguration(v.S3BucketSinkConfiguration); err != nil {
			invalidParams.AddNested("S3BucketSinkConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateConcatenationSource(v *types.ConcatenationSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConcatenationSource"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.MediaCapturePipelineSourceConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaCapturePipelineSourceConfiguration"))
	} else if v.MediaCapturePipelineSourceConfiguration != nil {
		if err := validateMediaCapturePipelineSourceConfiguration(v.MediaCapturePipelineSourceConfiguration); err != nil {
			invalidParams.AddNested("MediaCapturePipelineSourceConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateFragmentSelector(v *types.FragmentSelector) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FragmentSelector"}
	if len(v.FragmentSelectorType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FragmentSelectorType"))
	}
	if v.TimestampRange == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimestampRange"))
	} else if v.TimestampRange != nil {
		if err := validateTimestampRange(v.TimestampRange); err != nil {
			invalidParams.AddNested("TimestampRange", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateKeywordMatchConfiguration(v *types.KeywordMatchConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeywordMatchConfiguration"}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if v.Keywords == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Keywords"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateKinesisVideoStreamRecordingSourceRuntimeConfiguration(v *types.KinesisVideoStreamRecordingSourceRuntimeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisVideoStreamRecordingSourceRuntimeConfiguration"}
	if v.Streams == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Streams"))
	}
	if v.FragmentSelector == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FragmentSelector"))
	} else if v.FragmentSelector != nil {
		if err := validateFragmentSelector(v.FragmentSelector); err != nil {
			invalidParams.AddNested("FragmentSelector", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateKinesisVideoStreamSourceRuntimeConfiguration(v *types.KinesisVideoStreamSourceRuntimeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KinesisVideoStreamSourceRuntimeConfiguration"}
	if v.Streams == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Streams"))
	} else if v.Streams != nil {
		if err := validateStreams(v.Streams); err != nil {
			invalidParams.AddNested("Streams", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.MediaEncoding) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MediaEncoding"))
	}
	if v.MediaSampleRate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaSampleRate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateLiveConnectorSinkConfiguration(v *types.LiveConnectorSinkConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LiveConnectorSinkConfiguration"}
	if len(v.SinkType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SinkType"))
	}
	if v.RTMPConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RTMPConfiguration"))
	} else if v.RTMPConfiguration != nil {
		if err := validateLiveConnectorRTMPConfiguration(v.RTMPConfiguration); err != nil {
			invalidParams.AddNested("RTMPConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLiveConnectorSourceConfiguration(v *types.LiveConnectorSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LiveConnectorSourceConfiguration"}
	if len(v.SourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
	}
	if v.ChimeSdkMeetingLiveConnectorConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChimeSdkMeetingLiveConnectorConfiguration"))
	} else if v.ChimeSdkMeetingLiveConnectorConfiguration != nil {
		if err := validateChimeSdkMeetingLiveConnectorConfiguration(v.ChimeSdkMeetingLiveConnectorConfiguration); err != nil {
			invalidParams.AddNested("ChimeSdkMeetingLiveConnectorConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMediaCapturePipelineSourceConfiguration(v *types.MediaCapturePipelineSourceConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaCapturePipelineSourceConfiguration"}
	if v.MediaPipelineArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaPipelineArn"))
	}
	if v.ChimeSdkMeetingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChimeSdkMeetingConfiguration"))
	} else if v.ChimeSdkMeetingConfiguration != nil {
		if err := validateChimeSdkMeetingConcatenationConfiguration(v.ChimeSdkMeetingConfiguration); err != nil {
			invalidParams.AddNested("ChimeSdkMeetingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMediaInsightsPipelineConfigurationElement(v *types.MediaInsightsPipelineConfigurationElement) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaInsightsPipelineConfigurationElement"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.AmazonTranscribeCallAnalyticsProcessorConfiguration != nil {
		if err := validateAmazonTranscribeCallAnalyticsProcessorConfiguration(v.AmazonTranscribeCallAnalyticsProcessorConfiguration); err != nil {
			invalidParams.AddNested("AmazonTranscribeCallAnalyticsProcessorConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMediaStreamSink(v *types.MediaStreamSink) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaStreamSink"}
	if v.SinkArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SinkArn"))
	}
	if len(v.SinkType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SinkType"))
	}
	if v.ReservedStreamCapacity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedStreamCapacity"))
	}
	if len(v.MediaStreamType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MediaStreamType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMediaStreamSource(v *types.MediaStreamSource) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MediaStreamSource"}
	if len(v.SourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
	}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validatePostCallAnalyticsSettings(v *types.PostCallAnalyticsSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostCallAnalyticsSettings"}
	if v.OutputLocation == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputLocation"))
	}
	if v.DataAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataAccessRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRealTimeAlertConfiguration(v *types.RealTimeAlertConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RealTimeAlertConfiguration"}
	if v.Rules != nil {
		if err := validateRealTimeAlertRuleList(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRealTimeAlertRule(v *types.RealTimeAlertRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RealTimeAlertRule"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.KeywordMatchConfiguration != nil {
		if err := validateKeywordMatchConfiguration(v.KeywordMatchConfiguration); err != nil {
			invalidParams.AddNested("KeywordMatchConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SentimentConfiguration != nil {
		if err := validateSentimentConfiguration(v.SentimentConfiguration); err != nil {
			invalidParams.AddNested("SentimentConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.IssueDetectionConfiguration != nil {
		if err := validateIssueDetectionConfiguration(v.IssueDetectionConfiguration); err != nil {
			invalidParams.AddNested("IssueDetectionConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateS3RecordingSinkRuntimeConfiguration(v *types.S3RecordingSinkRuntimeConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "S3RecordingSinkRuntimeConfiguration"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if len(v.RecordingFileFormat) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("RecordingFileFormat"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSentimentConfiguration(v *types.SentimentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SentimentConfiguration"}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if len(v.SentimentType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SentimentType"))
	}
	if v.TimePeriod == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimePeriod"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStreamChannelDefinition(v *types.StreamChannelDefinition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamChannelDefinition"}
	if v.NumberOfChannels == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NumberOfChannels"))
	}
	if v.ChannelDefinitions != nil {
		if err := validateChannelDefinitions(v.ChannelDefinitions); err != nil {
			invalidParams.AddNested("ChannelDefinitions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStreamConfiguration(v *types.StreamConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StreamConfiguration"}
	if v.StreamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamArn"))
	}
	if v.StreamChannelDefinition == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StreamChannelDefinition"))
	} else if v.StreamChannelDefinition != nil {
		if err := validateStreamChannelDefinition(v.StreamChannelDefinition); err != nil {
			invalidParams.AddNested("StreamChannelDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

func validateOpCreateMediaCapturePipelineInput(v *CreateMediaCapturePipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaCapturePipelineInput"}
	if len(v.SourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SourceType"))
	}
	if v.SourceArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceArn"))
	}
	if len(v.SinkType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SinkType"))
	}
	if v.SinkArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SinkArn"))
	}
	if v.ChimeSdkMeetingConfiguration != nil {
		if err := validateChimeSdkMeetingConfiguration(v.ChimeSdkMeetingConfiguration); err != nil {
			invalidParams.AddNested("ChimeSdkMeetingConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.SseAwsKeyManagementParams != nil {
		if err := validateSseAwsKeyManagementParams(v.SseAwsKeyManagementParams); err != nil {
			invalidParams.AddNested("SseAwsKeyManagementParams", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMediaConcatenationPipelineInput(v *CreateMediaConcatenationPipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaConcatenationPipelineInput"}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validateConcatenationSourceList(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sinks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sinks"))
	} else if v.Sinks != nil {
		if err := validateConcatenationSinkList(v.Sinks); err != nil {
			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMediaInsightsPipelineConfigurationInput(v *CreateMediaInsightsPipelineConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaInsightsPipelineConfigurationInput"}
	if v.MediaInsightsPipelineConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaInsightsPipelineConfigurationName"))
	}
	if v.ResourceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceAccessRoleArn"))
	}
	if v.RealTimeAlertConfiguration != nil {
		if err := validateRealTimeAlertConfiguration(v.RealTimeAlertConfiguration); err != nil {
			invalidParams.AddNested("RealTimeAlertConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Elements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Elements"))
	} else if v.Elements != nil {
		if err := validateMediaInsightsPipelineConfigurationElements(v.Elements); err != nil {
			invalidParams.AddNested("Elements", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMediaInsightsPipelineInput(v *CreateMediaInsightsPipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaInsightsPipelineInput"}
	if v.MediaInsightsPipelineConfigurationArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MediaInsightsPipelineConfigurationArn"))
	}
	if v.KinesisVideoStreamSourceRuntimeConfiguration != nil {
		if err := validateKinesisVideoStreamSourceRuntimeConfiguration(v.KinesisVideoStreamSourceRuntimeConfiguration); err != nil {
			invalidParams.AddNested("KinesisVideoStreamSourceRuntimeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.KinesisVideoStreamRecordingSourceRuntimeConfiguration != nil {
		if err := validateKinesisVideoStreamRecordingSourceRuntimeConfiguration(v.KinesisVideoStreamRecordingSourceRuntimeConfiguration); err != nil {
			invalidParams.AddNested("KinesisVideoStreamRecordingSourceRuntimeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.S3RecordingSinkRuntimeConfiguration != nil {
		if err := validateS3RecordingSinkRuntimeConfiguration(v.S3RecordingSinkRuntimeConfiguration); err != nil {
			invalidParams.AddNested("S3RecordingSinkRuntimeConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMediaLiveConnectorPipelineInput(v *CreateMediaLiveConnectorPipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaLiveConnectorPipelineInput"}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validateLiveConnectorSourceList(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sinks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sinks"))
	} else if v.Sinks != nil {
		if err := validateLiveConnectorSinkList(v.Sinks); err != nil {
			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateMediaStreamPipelineInput(v *CreateMediaStreamPipelineInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMediaStreamPipelineInput"}
	if v.Sources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sources"))
	} else if v.Sources != nil {
		if err := validateMediaStreamSourceList(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sinks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sinks"))
	} else if v.Sinks != nil {
		if err := validateMediaStreamSinkList(v.Sinks); err != nil {
			invalidParams.AddNested("Sinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.Tags != nil {
		if err := validateTagList(v.Tags); err != nil {
			invalidParams.AddNested("Tags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpGetSpeakerSearchTaskInput(v *GetSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSpeakerSearchTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetVoiceToneAnalysisTaskInput(v *GetVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetVoiceToneAnalysisTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.VoiceToneAnalysisTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceToneAnalysisTaskId"))
	}
	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 validateOpStartSpeakerSearchTaskInput(v *StartSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSpeakerSearchTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.VoiceProfileDomainArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceProfileDomainArn"))
	}
	if v.KinesisVideoStreamSourceTaskConfiguration != nil {
		if err := validateKinesisVideoStreamSourceTaskConfiguration(v.KinesisVideoStreamSourceTaskConfiguration); err != nil {
			invalidParams.AddNested("KinesisVideoStreamSourceTaskConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartVoiceToneAnalysisTaskInput(v *StartVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartVoiceToneAnalysisTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if len(v.LanguageCode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.KinesisVideoStreamSourceTaskConfiguration != nil {
		if err := validateKinesisVideoStreamSourceTaskConfiguration(v.KinesisVideoStreamSourceTaskConfiguration); err != nil {
			invalidParams.AddNested("KinesisVideoStreamSourceTaskConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopSpeakerSearchTaskInput(v *StopSpeakerSearchTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopSpeakerSearchTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.SpeakerSearchTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SpeakerSearchTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStopVoiceToneAnalysisTaskInput(v *StopVoiceToneAnalysisTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopVoiceToneAnalysisTaskInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.VoiceToneAnalysisTaskId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VoiceToneAnalysisTaskId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUntagResourceInput(v *UntagResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UntagResourceInput"}
	if v.ResourceARN == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceARN"))
	}
	if v.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMediaInsightsPipelineConfigurationInput(v *UpdateMediaInsightsPipelineConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMediaInsightsPipelineConfigurationInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.ResourceAccessRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceAccessRoleArn"))
	}
	if v.RealTimeAlertConfiguration != nil {
		if err := validateRealTimeAlertConfiguration(v.RealTimeAlertConfiguration); err != nil {
			invalidParams.AddNested("RealTimeAlertConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.Elements == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Elements"))
	} else if v.Elements != nil {
		if err := validateMediaInsightsPipelineConfigurationElements(v.Elements); err != nil {
			invalidParams.AddNested("Elements", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMediaInsightsPipelineStatusInput(v *UpdateMediaInsightsPipelineStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMediaInsightsPipelineStatusInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if len(v.UpdateStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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