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

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 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 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 addOpListTagsForResourceValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResource{}, 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 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 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 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 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 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.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 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 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 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 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
	}
}