service/medialive/validators.go

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

package medialive

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

type validateOpAcceptInputDeviceTransfer struct {
}

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

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

type validateOpBatchUpdateSchedule struct {
}

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

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

type validateOpCancelInputDeviceTransfer struct {
}

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

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

type validateOpCreateChannel struct {
}

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

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

type validateOpCreateChannelPlacementGroup struct {
}

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

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

type validateOpCreateCloudWatchAlarmTemplateGroup struct {
}

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

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

type validateOpCreateCloudWatchAlarmTemplate struct {
}

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

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

type validateOpCreateEventBridgeRuleTemplateGroup struct {
}

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

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

type validateOpCreateEventBridgeRuleTemplate struct {
}

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

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

type validateOpCreateInput struct {
}

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

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

type validateOpCreateMultiplex struct {
}

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

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

type validateOpCreateMultiplexProgram struct {
}

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

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

type validateOpCreateNode struct {
}

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

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

type validateOpCreateNodeRegistrationScript struct {
}

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

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

type validateOpCreatePartnerInput struct {
}

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

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

type validateOpCreateSignalMap struct {
}

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

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

type validateOpCreateTags struct {
}

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

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

type validateOpDeleteChannel struct {
}

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

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

type validateOpDeleteChannelPlacementGroup struct {
}

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

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

type validateOpDeleteCloudWatchAlarmTemplateGroup struct {
}

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

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

type validateOpDeleteCloudWatchAlarmTemplate struct {
}

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

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

type validateOpDeleteCluster struct {
}

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

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

type validateOpDeleteEventBridgeRuleTemplateGroup struct {
}

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

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

type validateOpDeleteEventBridgeRuleTemplate struct {
}

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

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

type validateOpDeleteInput struct {
}

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

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

type validateOpDeleteInputSecurityGroup struct {
}

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

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

type validateOpDeleteMultiplex struct {
}

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

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

type validateOpDeleteMultiplexProgram struct {
}

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

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

type validateOpDeleteNetwork struct {
}

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

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

type validateOpDeleteNode struct {
}

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

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

type validateOpDeleteReservation struct {
}

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

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

type validateOpDeleteSchedule struct {
}

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

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

type validateOpDeleteSdiSource struct {
}

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

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

type validateOpDeleteSignalMap struct {
}

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

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

type validateOpDeleteTags struct {
}

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

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

type validateOpDescribeChannel struct {
}

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

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

type validateOpDescribeChannelPlacementGroup struct {
}

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

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

type validateOpDescribeCluster struct {
}

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

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

type validateOpDescribeInputDevice struct {
}

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

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

type validateOpDescribeInputDeviceThumbnail struct {
}

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

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

type validateOpDescribeInput struct {
}

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

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

type validateOpDescribeInputSecurityGroup struct {
}

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

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

type validateOpDescribeMultiplex struct {
}

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

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

type validateOpDescribeMultiplexProgram struct {
}

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

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

type validateOpDescribeNetwork struct {
}

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

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

type validateOpDescribeNode struct {
}

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

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

type validateOpDescribeOffering struct {
}

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

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

type validateOpDescribeReservation struct {
}

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

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

type validateOpDescribeSchedule struct {
}

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

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

type validateOpDescribeSdiSource struct {
}

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

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

type validateOpDescribeThumbnails struct {
}

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

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

type validateOpGetCloudWatchAlarmTemplateGroup struct {
}

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

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

type validateOpGetCloudWatchAlarmTemplate struct {
}

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

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

type validateOpGetEventBridgeRuleTemplateGroup struct {
}

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

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

type validateOpGetEventBridgeRuleTemplate struct {
}

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

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

type validateOpGetSignalMap struct {
}

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

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

type validateOpListChannelPlacementGroups struct {
}

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

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

type validateOpListInputDeviceTransfers struct {
}

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

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

type validateOpListMultiplexPrograms struct {
}

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

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

type validateOpListNodes struct {
}

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

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

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

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

type validateOpRebootInputDevice struct {
}

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

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

type validateOpRejectInputDeviceTransfer struct {
}

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

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

type validateOpRestartChannelPipelines struct {
}

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

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

type validateOpStartChannel struct {
}

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

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

type validateOpStartDeleteMonitorDeployment struct {
}

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

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

type validateOpStartInputDevice struct {
}

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

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

type validateOpStartInputDeviceMaintenanceWindow struct {
}

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

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

type validateOpStartMonitorDeployment struct {
}

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

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

type validateOpStartMultiplex struct {
}

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

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

type validateOpStartUpdateSignalMap struct {
}

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

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

type validateOpStopChannel struct {
}

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

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

type validateOpStopInputDevice struct {
}

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

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

type validateOpStopMultiplex struct {
}

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

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

type validateOpTransferInputDevice struct {
}

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

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

type validateOpUpdateChannelClass struct {
}

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

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

type validateOpUpdateChannel struct {
}

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

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

type validateOpUpdateChannelPlacementGroup struct {
}

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

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

type validateOpUpdateCloudWatchAlarmTemplateGroup struct {
}

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

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

type validateOpUpdateCloudWatchAlarmTemplate struct {
}

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

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

type validateOpUpdateCluster struct {
}

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

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

type validateOpUpdateEventBridgeRuleTemplateGroup struct {
}

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

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

type validateOpUpdateEventBridgeRuleTemplate struct {
}

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

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

type validateOpUpdateInputDevice struct {
}

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

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

type validateOpUpdateInput struct {
}

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

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

type validateOpUpdateInputSecurityGroup struct {
}

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

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

type validateOpUpdateMultiplex struct {
}

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

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

type validateOpUpdateMultiplexProgram struct {
}

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

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

type validateOpUpdateNetwork struct {
}

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

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

type validateOpUpdateNode struct {
}

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

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

type validateOpUpdateNodeState struct {
}

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

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

type validateOpUpdateReservation struct {
}

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

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

type validateOpUpdateSdiSource struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateArchiveContainerSettings(v *types.ArchiveContainerSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ArchiveContainerSettings"}
	if v.M2tsSettings != nil {
		if err := validateM2tsSettings(v.M2tsSettings); err != nil {
			invalidParams.AddNested("M2tsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateArchiveOutputSettings(v *types.ArchiveOutputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ArchiveOutputSettings"}
	if v.ContainerSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerSettings"))
	} else if v.ContainerSettings != nil {
		if err := validateArchiveContainerSettings(v.ContainerSettings); err != nil {
			invalidParams.AddNested("ContainerSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioChannelMapping(v *types.AudioChannelMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioChannelMapping"}
	if v.InputChannelLevels == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputChannelLevels"))
	} else if v.InputChannelLevels != nil {
		if err := validate__listOfInputChannelLevel(v.InputChannelLevels); err != nil {
			invalidParams.AddNested("InputChannelLevels", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputChannel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioDescription(v *types.AudioDescription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioDescription"}
	if v.AudioSelectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AudioSelectorName"))
	}
	if v.AudioWatermarkingSettings != nil {
		if err := validateAudioWatermarkSettings(v.AudioWatermarkingSettings); err != nil {
			invalidParams.AddNested("AudioWatermarkingSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RemixSettings != nil {
		if err := validateRemixSettings(v.RemixSettings); err != nil {
			invalidParams.AddNested("RemixSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateAudioOnlyHlsSettings(v *types.AudioOnlyHlsSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioOnlyHlsSettings"}
	if v.AudioOnlyImage != nil {
		if err := validateInputLocation(v.AudioOnlyImage); err != nil {
			invalidParams.AddNested("AudioOnlyImage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAudioSelector(v *types.AudioSelector) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioSelector"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SelectorSettings != nil {
		if err := validateAudioSelectorSettings(v.SelectorSettings); err != nil {
			invalidParams.AddNested("SelectorSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioSelectorSettings(v *types.AudioSelectorSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioSelectorSettings"}
	if v.AudioHlsRenditionSelection != nil {
		if err := validateAudioHlsRenditionSelection(v.AudioHlsRenditionSelection); err != nil {
			invalidParams.AddNested("AudioHlsRenditionSelection", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioLanguageSelection != nil {
		if err := validateAudioLanguageSelection(v.AudioLanguageSelection); err != nil {
			invalidParams.AddNested("AudioLanguageSelection", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioPidSelection != nil {
		if err := validateAudioPidSelection(v.AudioPidSelection); err != nil {
			invalidParams.AddNested("AudioPidSelection", err.(smithy.InvalidParamsError))
		}
	}
	if v.AudioTrackSelection != nil {
		if err := validateAudioTrackSelection(v.AudioTrackSelection); err != nil {
			invalidParams.AddNested("AudioTrackSelection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateAudioTrackSelection(v *types.AudioTrackSelection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioTrackSelection"}
	if v.Tracks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Tracks"))
	} else if v.Tracks != nil {
		if err := validate__listOfAudioTrack(v.Tracks); err != nil {
			invalidParams.AddNested("Tracks", err.(smithy.InvalidParamsError))
		}
	}
	if v.DolbyEDecode != nil {
		if err := validateAudioDolbyEDecode(v.DolbyEDecode); err != nil {
			invalidParams.AddNested("DolbyEDecode", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAudioWatermarkSettings(v *types.AudioWatermarkSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AudioWatermarkSettings"}
	if v.NielsenWatermarksSettings != nil {
		if err := validateNielsenWatermarksSettings(v.NielsenWatermarksSettings); err != nil {
			invalidParams.AddNested("NielsenWatermarksSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAutomaticInputFailoverSettings(v *types.AutomaticInputFailoverSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AutomaticInputFailoverSettings"}
	if v.FailoverConditions != nil {
		if err := validate__listOfFailoverCondition(v.FailoverConditions); err != nil {
			invalidParams.AddNested("FailoverConditions", err.(smithy.InvalidParamsError))
		}
	}
	if v.SecondaryInputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SecondaryInputId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAv1Settings(v *types.Av1Settings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Av1Settings"}
	if v.FramerateDenominator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateDenominator"))
	}
	if v.FramerateNumerator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateNumerator"))
	}
	if v.TimecodeBurninSettings != nil {
		if err := validateTimecodeBurninSettings(v.TimecodeBurninSettings); err != nil {
			invalidParams.AddNested("TimecodeBurninSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAvailBlanking(v *types.AvailBlanking) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AvailBlanking"}
	if v.AvailBlankingImage != nil {
		if err := validateInputLocation(v.AvailBlankingImage); err != nil {
			invalidParams.AddNested("AvailBlankingImage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAvailConfiguration(v *types.AvailConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AvailConfiguration"}
	if v.AvailSettings != nil {
		if err := validateAvailSettings(v.AvailSettings); err != nil {
			invalidParams.AddNested("AvailSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAvailSettings(v *types.AvailSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AvailSettings"}
	if v.Esam != nil {
		if err := validateEsam(v.Esam); err != nil {
			invalidParams.AddNested("Esam", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchScheduleActionCreateRequest(v *types.BatchScheduleActionCreateRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchScheduleActionCreateRequest"}
	if v.ScheduleActions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleActions"))
	} else if v.ScheduleActions != nil {
		if err := validate__listOfScheduleAction(v.ScheduleActions); err != nil {
			invalidParams.AddNested("ScheduleActions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBlackoutSlate(v *types.BlackoutSlate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BlackoutSlate"}
	if v.BlackoutSlateImage != nil {
		if err := validateInputLocation(v.BlackoutSlateImage); err != nil {
			invalidParams.AddNested("BlackoutSlateImage", err.(smithy.InvalidParamsError))
		}
	}
	if v.NetworkEndBlackoutImage != nil {
		if err := validateInputLocation(v.NetworkEndBlackoutImage); err != nil {
			invalidParams.AddNested("NetworkEndBlackoutImage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBurnInDestinationSettings(v *types.BurnInDestinationSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BurnInDestinationSettings"}
	if v.Font != nil {
		if err := validateInputLocation(v.Font); err != nil {
			invalidParams.AddNested("Font", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionDescription(v *types.CaptionDescription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionDescription"}
	if v.CaptionSelectorName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaptionSelectorName"))
	}
	if v.DestinationSettings != nil {
		if err := validateCaptionDestinationSettings(v.DestinationSettings); err != nil {
			invalidParams.AddNested("DestinationSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionDestinationSettings(v *types.CaptionDestinationSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionDestinationSettings"}
	if v.BurnInDestinationSettings != nil {
		if err := validateBurnInDestinationSettings(v.BurnInDestinationSettings); err != nil {
			invalidParams.AddNested("BurnInDestinationSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.DvbSubDestinationSettings != nil {
		if err := validateDvbSubDestinationSettings(v.DvbSubDestinationSettings); err != nil {
			invalidParams.AddNested("DvbSubDestinationSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionLanguageMapping(v *types.CaptionLanguageMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionLanguageMapping"}
	if v.CaptionChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaptionChannel"))
	}
	if v.LanguageCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if v.LanguageDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionRectangle(v *types.CaptionRectangle) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionRectangle"}
	if v.Height == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Height"))
	}
	if v.LeftOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LeftOffset"))
	}
	if v.TopOffset == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TopOffset"))
	}
	if v.Width == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Width"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionSelector(v *types.CaptionSelector) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionSelector"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.SelectorSettings != nil {
		if err := validateCaptionSelectorSettings(v.SelectorSettings); err != nil {
			invalidParams.AddNested("SelectorSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCaptionSelectorSettings(v *types.CaptionSelectorSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CaptionSelectorSettings"}
	if v.TeletextSourceSettings != nil {
		if err := validateTeletextSourceSettings(v.TeletextSourceSettings); err != nil {
			invalidParams.AddNested("TeletextSourceSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCmafIngestCaptionLanguageMapping(v *types.CmafIngestCaptionLanguageMapping) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CmafIngestCaptionLanguageMapping"}
	if v.CaptionChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CaptionChannel"))
	}
	if v.LanguageCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LanguageCode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCmafIngestGroupSettings(v *types.CmafIngestGroupSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CmafIngestGroupSettings"}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if v.CaptionLanguageMappings != nil {
		if err := validate__listOfCmafIngestCaptionLanguageMapping(v.CaptionLanguageMappings); err != nil {
			invalidParams.AddNested("CaptionLanguageMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColorCorrection(v *types.ColorCorrection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColorCorrection"}
	if len(v.InputColorSpace) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("InputColorSpace"))
	}
	if len(v.OutputColorSpace) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("OutputColorSpace"))
	}
	if v.Uri == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Uri"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateColorCorrectionSettings(v *types.ColorCorrectionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ColorCorrectionSettings"}
	if v.GlobalColorCorrections == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalColorCorrections"))
	} else if v.GlobalColorCorrections != nil {
		if err := validate__listOfColorCorrection(v.GlobalColorCorrections); err != nil {
			invalidParams.AddNested("GlobalColorCorrections", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDvbNitSettings(v *types.DvbNitSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DvbNitSettings"}
	if v.NetworkId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkId"))
	}
	if v.NetworkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NetworkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDvbSubDestinationSettings(v *types.DvbSubDestinationSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DvbSubDestinationSettings"}
	if v.Font != nil {
		if err := validateInputLocation(v.Font); err != nil {
			invalidParams.AddNested("Font", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEncoderSettings(v *types.EncoderSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EncoderSettings"}
	if v.AudioDescriptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AudioDescriptions"))
	} else if v.AudioDescriptions != nil {
		if err := validate__listOfAudioDescription(v.AudioDescriptions); err != nil {
			invalidParams.AddNested("AudioDescriptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.AvailBlanking != nil {
		if err := validateAvailBlanking(v.AvailBlanking); err != nil {
			invalidParams.AddNested("AvailBlanking", err.(smithy.InvalidParamsError))
		}
	}
	if v.AvailConfiguration != nil {
		if err := validateAvailConfiguration(v.AvailConfiguration); err != nil {
			invalidParams.AddNested("AvailConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.BlackoutSlate != nil {
		if err := validateBlackoutSlate(v.BlackoutSlate); err != nil {
			invalidParams.AddNested("BlackoutSlate", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptionDescriptions != nil {
		if err := validate__listOfCaptionDescription(v.CaptionDescriptions); err != nil {
			invalidParams.AddNested("CaptionDescriptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.GlobalConfiguration != nil {
		if err := validateGlobalConfiguration(v.GlobalConfiguration); err != nil {
			invalidParams.AddNested("GlobalConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.MotionGraphicsConfiguration != nil {
		if err := validateMotionGraphicsConfiguration(v.MotionGraphicsConfiguration); err != nil {
			invalidParams.AddNested("MotionGraphicsConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputGroups == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputGroups"))
	} else if v.OutputGroups != nil {
		if err := validate__listOfOutputGroup(v.OutputGroups); err != nil {
			invalidParams.AddNested("OutputGroups", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimecodeConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TimecodeConfig"))
	} else if v.TimecodeConfig != nil {
		if err := validateTimecodeConfig(v.TimecodeConfig); err != nil {
			invalidParams.AddNested("TimecodeConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.VideoDescriptions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VideoDescriptions"))
	} else if v.VideoDescriptions != nil {
		if err := validate__listOfVideoDescription(v.VideoDescriptions); err != nil {
			invalidParams.AddNested("VideoDescriptions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ThumbnailConfiguration != nil {
		if err := validateThumbnailConfiguration(v.ThumbnailConfiguration); err != nil {
			invalidParams.AddNested("ThumbnailConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ColorCorrectionSettings != nil {
		if err := validateColorCorrectionSettings(v.ColorCorrectionSettings); err != nil {
			invalidParams.AddNested("ColorCorrectionSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateEsam(v *types.Esam) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Esam"}
	if v.AcquisitionPointId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AcquisitionPointId"))
	}
	if v.PoisEndpoint == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PoisEndpoint"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFailoverCondition(v *types.FailoverCondition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailoverCondition"}
	if v.FailoverConditionSettings != nil {
		if err := validateFailoverConditionSettings(v.FailoverConditionSettings); err != nil {
			invalidParams.AddNested("FailoverConditionSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFailoverConditionSettings(v *types.FailoverConditionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailoverConditionSettings"}
	if v.AudioSilenceSettings != nil {
		if err := validateAudioSilenceFailoverSettings(v.AudioSilenceSettings); err != nil {
			invalidParams.AddNested("AudioSilenceSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFollowModeScheduleActionStartSettings(v *types.FollowModeScheduleActionStartSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FollowModeScheduleActionStartSettings"}
	if len(v.FollowPoint) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FollowPoint"))
	}
	if v.ReferenceActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReferenceActionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFrameCaptureSettings(v *types.FrameCaptureSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FrameCaptureSettings"}
	if v.TimecodeBurninSettings != nil {
		if err := validateTimecodeBurninSettings(v.TimecodeBurninSettings); err != nil {
			invalidParams.AddNested("TimecodeBurninSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGlobalConfiguration(v *types.GlobalConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlobalConfiguration"}
	if v.InputLossBehavior != nil {
		if err := validateInputLossBehavior(v.InputLossBehavior); err != nil {
			invalidParams.AddNested("InputLossBehavior", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateH264Settings(v *types.H264Settings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "H264Settings"}
	if v.TimecodeBurninSettings != nil {
		if err := validateTimecodeBurninSettings(v.TimecodeBurninSettings); err != nil {
			invalidParams.AddNested("TimecodeBurninSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateH265Settings(v *types.H265Settings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "H265Settings"}
	if v.FramerateDenominator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateDenominator"))
	}
	if v.FramerateNumerator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateNumerator"))
	}
	if v.TimecodeBurninSettings != nil {
		if err := validateTimecodeBurninSettings(v.TimecodeBurninSettings); err != nil {
			invalidParams.AddNested("TimecodeBurninSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHlsGroupSettings(v *types.HlsGroupSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HlsGroupSettings"}
	if v.CaptionLanguageMappings != nil {
		if err := validate__listOfCaptionLanguageMapping(v.CaptionLanguageMappings); err != nil {
			invalidParams.AddNested("CaptionLanguageMappings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if v.KeyProviderSettings != nil {
		if err := validateKeyProviderSettings(v.KeyProviderSettings); err != nil {
			invalidParams.AddNested("KeyProviderSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHlsOutputSettings(v *types.HlsOutputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HlsOutputSettings"}
	if v.HlsSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HlsSettings"))
	} else if v.HlsSettings != nil {
		if err := validateHlsSettings(v.HlsSettings); err != nil {
			invalidParams.AddNested("HlsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateHlsSettings(v *types.HlsSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "HlsSettings"}
	if v.AudioOnlyHlsSettings != nil {
		if err := validateAudioOnlyHlsSettings(v.AudioOnlyHlsSettings); err != nil {
			invalidParams.AddNested("AudioOnlyHlsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.StandardHlsSettings != nil {
		if err := validateStandardHlsSettings(v.StandardHlsSettings); err != nil {
			invalidParams.AddNested("StandardHlsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateInputAttachment(v *types.InputAttachment) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputAttachment"}
	if v.AutomaticInputFailoverSettings != nil {
		if err := validateAutomaticInputFailoverSettings(v.AutomaticInputFailoverSettings); err != nil {
			invalidParams.AddNested("AutomaticInputFailoverSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputSettings != nil {
		if err := validateInputSettings(v.InputSettings); err != nil {
			invalidParams.AddNested("InputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputChannelLevel(v *types.InputChannelLevel) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputChannelLevel"}
	if v.Gain == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Gain"))
	}
	if v.InputChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputChannel"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateInputLossBehavior(v *types.InputLossBehavior) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputLossBehavior"}
	if v.InputLossImageSlate != nil {
		if err := validateInputLocation(v.InputLossImageSlate); err != nil {
			invalidParams.AddNested("InputLossImageSlate", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputPrepareScheduleActionSettings(v *types.InputPrepareScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputPrepareScheduleActionSettings"}
	if v.InputClippingSettings != nil {
		if err := validateInputClippingSettings(v.InputClippingSettings); err != nil {
			invalidParams.AddNested("InputClippingSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputSettings(v *types.InputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputSettings"}
	if v.AudioSelectors != nil {
		if err := validate__listOfAudioSelector(v.AudioSelectors); err != nil {
			invalidParams.AddNested("AudioSelectors", err.(smithy.InvalidParamsError))
		}
	}
	if v.CaptionSelectors != nil {
		if err := validate__listOfCaptionSelector(v.CaptionSelectors); err != nil {
			invalidParams.AddNested("CaptionSelectors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateInputSwitchScheduleActionSettings(v *types.InputSwitchScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InputSwitchScheduleActionSettings"}
	if v.InputAttachmentNameReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputAttachmentNameReference"))
	}
	if v.InputClippingSettings != nil {
		if err := validateInputClippingSettings(v.InputClippingSettings); err != nil {
			invalidParams.AddNested("InputClippingSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateKeyProviderSettings(v *types.KeyProviderSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyProviderSettings"}
	if v.StaticKeySettings != nil {
		if err := validateStaticKeySettings(v.StaticKeySettings); err != nil {
			invalidParams.AddNested("StaticKeySettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateM2tsSettings(v *types.M2tsSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "M2tsSettings"}
	if v.DvbNitSettings != nil {
		if err := validateDvbNitSettings(v.DvbNitSettings); err != nil {
			invalidParams.AddNested("DvbNitSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateMpeg2Settings(v *types.Mpeg2Settings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Mpeg2Settings"}
	if v.FramerateDenominator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateDenominator"))
	}
	if v.FramerateNumerator == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FramerateNumerator"))
	}
	if v.TimecodeBurninSettings != nil {
		if err := validateTimecodeBurninSettings(v.TimecodeBurninSettings); err != nil {
			invalidParams.AddNested("TimecodeBurninSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMulticastSettingsCreateRequest(v *types.MulticastSettingsCreateRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MulticastSettingsCreateRequest"}
	if v.Sources != nil {
		if err := validate__listOfMulticastSourceCreateRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMulticastSettingsUpdateRequest(v *types.MulticastSettingsUpdateRequest) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MulticastSettingsUpdateRequest"}
	if v.Sources != nil {
		if err := validate__listOfMulticastSourceUpdateRequest(v.Sources); err != nil {
			invalidParams.AddNested("Sources", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateMultiplexProgramServiceDescriptor(v *types.MultiplexProgramServiceDescriptor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiplexProgramServiceDescriptor"}
	if v.ProviderName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProviderName"))
	}
	if v.ServiceName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServiceName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMultiplexProgramSettings(v *types.MultiplexProgramSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiplexProgramSettings"}
	if v.ProgramNumber == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgramNumber"))
	}
	if v.ServiceDescriptor != nil {
		if err := validateMultiplexProgramServiceDescriptor(v.ServiceDescriptor); err != nil {
			invalidParams.AddNested("ServiceDescriptor", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMultiplexSettings(v *types.MultiplexSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MultiplexSettings"}
	if v.TransportStreamBitrate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransportStreamBitrate"))
	}
	if v.TransportStreamId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TransportStreamId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNielsenCBET(v *types.NielsenCBET) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NielsenCBET"}
	if v.CbetCheckDigitString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CbetCheckDigitString"))
	}
	if len(v.CbetStepaside) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("CbetStepaside"))
	}
	if v.Csid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Csid"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNielsenNaesIiNw(v *types.NielsenNaesIiNw) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NielsenNaesIiNw"}
	if v.CheckDigitString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CheckDigitString"))
	}
	if v.Sid == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Sid"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateNielsenWatermarksSettings(v *types.NielsenWatermarksSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NielsenWatermarksSettings"}
	if v.NielsenCbetSettings != nil {
		if err := validateNielsenCBET(v.NielsenCbetSettings); err != nil {
			invalidParams.AddNested("NielsenCbetSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.NielsenNaesIiNwSettings != nil {
		if err := validateNielsenNaesIiNw(v.NielsenNaesIiNwSettings); err != nil {
			invalidParams.AddNested("NielsenNaesIiNwSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOutput(v *types.Output) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Output"}
	if v.OutputSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputSettings"))
	} else if v.OutputSettings != nil {
		if err := validateOutputSettings(v.OutputSettings); err != nil {
			invalidParams.AddNested("OutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOutputGroup(v *types.OutputGroup) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputGroup"}
	if v.OutputGroupSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputGroupSettings"))
	} else if v.OutputGroupSettings != nil {
		if err := validateOutputGroupSettings(v.OutputGroupSettings); err != nil {
			invalidParams.AddNested("OutputGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Outputs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Outputs"))
	} else if v.Outputs != nil {
		if err := validate__listOfOutput(v.Outputs); err != nil {
			invalidParams.AddNested("Outputs", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOutputGroupSettings(v *types.OutputGroupSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputGroupSettings"}
	if v.ArchiveGroupSettings != nil {
		if err := validateArchiveGroupSettings(v.ArchiveGroupSettings); err != nil {
			invalidParams.AddNested("ArchiveGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.FrameCaptureGroupSettings != nil {
		if err := validateFrameCaptureGroupSettings(v.FrameCaptureGroupSettings); err != nil {
			invalidParams.AddNested("FrameCaptureGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.HlsGroupSettings != nil {
		if err := validateHlsGroupSettings(v.HlsGroupSettings); err != nil {
			invalidParams.AddNested("HlsGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.MediaPackageGroupSettings != nil {
		if err := validateMediaPackageGroupSettings(v.MediaPackageGroupSettings); err != nil {
			invalidParams.AddNested("MediaPackageGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.MsSmoothGroupSettings != nil {
		if err := validateMsSmoothGroupSettings(v.MsSmoothGroupSettings); err != nil {
			invalidParams.AddNested("MsSmoothGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.CmafIngestGroupSettings != nil {
		if err := validateCmafIngestGroupSettings(v.CmafIngestGroupSettings); err != nil {
			invalidParams.AddNested("CmafIngestGroupSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOutputSettings(v *types.OutputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OutputSettings"}
	if v.ArchiveOutputSettings != nil {
		if err := validateArchiveOutputSettings(v.ArchiveOutputSettings); err != nil {
			invalidParams.AddNested("ArchiveOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.HlsOutputSettings != nil {
		if err := validateHlsOutputSettings(v.HlsOutputSettings); err != nil {
			invalidParams.AddNested("HlsOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.MultiplexOutputSettings != nil {
		if err := validateMultiplexOutputSettings(v.MultiplexOutputSettings); err != nil {
			invalidParams.AddNested("MultiplexOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.RtmpOutputSettings != nil {
		if err := validateRtmpOutputSettings(v.RtmpOutputSettings); err != nil {
			invalidParams.AddNested("RtmpOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.UdpOutputSettings != nil {
		if err := validateUdpOutputSettings(v.UdpOutputSettings); err != nil {
			invalidParams.AddNested("UdpOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.SrtOutputSettings != nil {
		if err := validateSrtOutputSettings(v.SrtOutputSettings); err != nil {
			invalidParams.AddNested("SrtOutputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validatePauseStateScheduleActionSettings(v *types.PauseStateScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PauseStateScheduleActionSettings"}
	if v.Pipelines != nil {
		if err := validate__listOfPipelinePauseStateSettings(v.Pipelines); err != nil {
			invalidParams.AddNested("Pipelines", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRemixSettings(v *types.RemixSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemixSettings"}
	if v.ChannelMappings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelMappings"))
	} else if v.ChannelMappings != nil {
		if err := validate__listOfAudioChannelMapping(v.ChannelMappings); err != nil {
			invalidParams.AddNested("ChannelMappings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScheduleAction(v *types.ScheduleAction) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduleAction"}
	if v.ActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionName"))
	}
	if v.ScheduleActionSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleActionSettings"))
	} else if v.ScheduleActionSettings != nil {
		if err := validateScheduleActionSettings(v.ScheduleActionSettings); err != nil {
			invalidParams.AddNested("ScheduleActionSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ScheduleActionStartSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleActionStartSettings"))
	} else if v.ScheduleActionStartSettings != nil {
		if err := validateScheduleActionStartSettings(v.ScheduleActionStartSettings); err != nil {
			invalidParams.AddNested("ScheduleActionStartSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScheduleActionSettings(v *types.ScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduleActionSettings"}
	if v.HlsTimedMetadataSettings != nil {
		if err := validateHlsTimedMetadataScheduleActionSettings(v.HlsTimedMetadataSettings); err != nil {
			invalidParams.AddNested("HlsTimedMetadataSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputPrepareSettings != nil {
		if err := validateInputPrepareScheduleActionSettings(v.InputPrepareSettings); err != nil {
			invalidParams.AddNested("InputPrepareSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputSwitchSettings != nil {
		if err := validateInputSwitchScheduleActionSettings(v.InputSwitchSettings); err != nil {
			invalidParams.AddNested("InputSwitchSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.PauseStateSettings != nil {
		if err := validatePauseStateScheduleActionSettings(v.PauseStateSettings); err != nil {
			invalidParams.AddNested("PauseStateSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Scte35InputSettings != nil {
		if err := validateScte35InputScheduleActionSettings(v.Scte35InputSettings); err != nil {
			invalidParams.AddNested("Scte35InputSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Scte35ReturnToNetworkSettings != nil {
		if err := validateScte35ReturnToNetworkScheduleActionSettings(v.Scte35ReturnToNetworkSettings); err != nil {
			invalidParams.AddNested("Scte35ReturnToNetworkSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Scte35SpliceInsertSettings != nil {
		if err := validateScte35SpliceInsertScheduleActionSettings(v.Scte35SpliceInsertSettings); err != nil {
			invalidParams.AddNested("Scte35SpliceInsertSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Scte35TimeSignalSettings != nil {
		if err := validateScte35TimeSignalScheduleActionSettings(v.Scte35TimeSignalSettings); err != nil {
			invalidParams.AddNested("Scte35TimeSignalSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.StaticImageActivateSettings != nil {
		if err := validateStaticImageActivateScheduleActionSettings(v.StaticImageActivateSettings); err != nil {
			invalidParams.AddNested("StaticImageActivateSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.StaticImageOutputActivateSettings != nil {
		if err := validateStaticImageOutputActivateScheduleActionSettings(v.StaticImageOutputActivateSettings); err != nil {
			invalidParams.AddNested("StaticImageOutputActivateSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.StaticImageOutputDeactivateSettings != nil {
		if err := validateStaticImageOutputDeactivateScheduleActionSettings(v.StaticImageOutputDeactivateSettings); err != nil {
			invalidParams.AddNested("StaticImageOutputDeactivateSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.TimedMetadataSettings != nil {
		if err := validateTimedMetadataScheduleActionSettings(v.TimedMetadataSettings); err != nil {
			invalidParams.AddNested("TimedMetadataSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScheduleActionStartSettings(v *types.ScheduleActionStartSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduleActionStartSettings"}
	if v.FixedModeScheduleActionStartSettings != nil {
		if err := validateFixedModeScheduleActionStartSettings(v.FixedModeScheduleActionStartSettings); err != nil {
			invalidParams.AddNested("FixedModeScheduleActionStartSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.FollowModeScheduleActionStartSettings != nil {
		if err := validateFollowModeScheduleActionStartSettings(v.FollowModeScheduleActionStartSettings); err != nil {
			invalidParams.AddNested("FollowModeScheduleActionStartSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScte35DeliveryRestrictions(v *types.Scte35DeliveryRestrictions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Scte35DeliveryRestrictions"}
	if len(v.ArchiveAllowedFlag) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ArchiveAllowedFlag"))
	}
	if len(v.DeviceRestrictions) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DeviceRestrictions"))
	}
	if len(v.NoRegionalBlackoutFlag) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("NoRegionalBlackoutFlag"))
	}
	if len(v.WebDeliveryAllowedFlag) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("WebDeliveryAllowedFlag"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScte35Descriptor(v *types.Scte35Descriptor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Scte35Descriptor"}
	if v.Scte35DescriptorSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scte35DescriptorSettings"))
	} else if v.Scte35DescriptorSettings != nil {
		if err := validateScte35DescriptorSettings(v.Scte35DescriptorSettings); err != nil {
			invalidParams.AddNested("Scte35DescriptorSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateScte35DescriptorSettings(v *types.Scte35DescriptorSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Scte35DescriptorSettings"}
	if v.SegmentationDescriptorScte35DescriptorSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentationDescriptorScte35DescriptorSettings"))
	} else if v.SegmentationDescriptorScte35DescriptorSettings != nil {
		if err := validateScte35SegmentationDescriptor(v.SegmentationDescriptorScte35DescriptorSettings); err != nil {
			invalidParams.AddNested("SegmentationDescriptorScte35DescriptorSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateScte35SegmentationDescriptor(v *types.Scte35SegmentationDescriptor) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Scte35SegmentationDescriptor"}
	if v.DeliveryRestrictions != nil {
		if err := validateScte35DeliveryRestrictions(v.DeliveryRestrictions); err != nil {
			invalidParams.AddNested("DeliveryRestrictions", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.SegmentationCancelIndicator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentationCancelIndicator"))
	}
	if v.SegmentationEventId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SegmentationEventId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScte35TimeSignalScheduleActionSettings(v *types.Scte35TimeSignalScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Scte35TimeSignalScheduleActionSettings"}
	if v.Scte35Descriptors == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scte35Descriptors"))
	} else if v.Scte35Descriptors != nil {
		if err := validate__listOfScte35Descriptor(v.Scte35Descriptors); err != nil {
			invalidParams.AddNested("Scte35Descriptors", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateSrtOutputSettings(v *types.SrtOutputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SrtOutputSettings"}
	if v.ContainerSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerSettings"))
	} else if v.ContainerSettings != nil {
		if err := validateUdpContainerSettings(v.ContainerSettings); err != nil {
			invalidParams.AddNested("ContainerSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStaticImageActivateScheduleActionSettings(v *types.StaticImageActivateScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StaticImageActivateScheduleActionSettings"}
	if v.Image == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Image"))
	} else if v.Image != nil {
		if err := validateInputLocation(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateStaticImageOutputActivateScheduleActionSettings(v *types.StaticImageOutputActivateScheduleActionSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StaticImageOutputActivateScheduleActionSettings"}
	if v.Image == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Image"))
	} else if v.Image != nil {
		if err := validateInputLocation(v.Image); err != nil {
			invalidParams.AddNested("Image", err.(smithy.InvalidParamsError))
		}
	}
	if v.OutputNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OutputNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateStaticKeySettings(v *types.StaticKeySettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StaticKeySettings"}
	if v.KeyProviderServer != nil {
		if err := validateInputLocation(v.KeyProviderServer); err != nil {
			invalidParams.AddNested("KeyProviderServer", err.(smithy.InvalidParamsError))
		}
	}
	if v.StaticKeyValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StaticKeyValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTeletextSourceSettings(v *types.TeletextSourceSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TeletextSourceSettings"}
	if v.OutputRectangle != nil {
		if err := validateCaptionRectangle(v.OutputRectangle); err != nil {
			invalidParams.AddNested("OutputRectangle", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimecodeBurninSettings(v *types.TimecodeBurninSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimecodeBurninSettings"}
	if len(v.FontSize) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FontSize"))
	}
	if len(v.Position) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Position"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateUdpContainerSettings(v *types.UdpContainerSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UdpContainerSettings"}
	if v.M2tsSettings != nil {
		if err := validateM2tsSettings(v.M2tsSettings); err != nil {
			invalidParams.AddNested("M2tsSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateUdpOutputSettings(v *types.UdpOutputSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UdpOutputSettings"}
	if v.ContainerSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ContainerSettings"))
	} else if v.ContainerSettings != nil {
		if err := validateUdpContainerSettings(v.ContainerSettings); err != nil {
			invalidParams.AddNested("ContainerSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Destination == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Destination"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVideoCodecSettings(v *types.VideoCodecSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoCodecSettings"}
	if v.FrameCaptureSettings != nil {
		if err := validateFrameCaptureSettings(v.FrameCaptureSettings); err != nil {
			invalidParams.AddNested("FrameCaptureSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.H264Settings != nil {
		if err := validateH264Settings(v.H264Settings); err != nil {
			invalidParams.AddNested("H264Settings", err.(smithy.InvalidParamsError))
		}
	}
	if v.H265Settings != nil {
		if err := validateH265Settings(v.H265Settings); err != nil {
			invalidParams.AddNested("H265Settings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Mpeg2Settings != nil {
		if err := validateMpeg2Settings(v.Mpeg2Settings); err != nil {
			invalidParams.AddNested("Mpeg2Settings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Av1Settings != nil {
		if err := validateAv1Settings(v.Av1Settings); err != nil {
			invalidParams.AddNested("Av1Settings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateVideoDescription(v *types.VideoDescription) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "VideoDescription"}
	if v.CodecSettings != nil {
		if err := validateVideoCodecSettings(v.CodecSettings); err != nil {
			invalidParams.AddNested("CodecSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpBatchUpdateScheduleInput(v *BatchUpdateScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateScheduleInput"}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if v.Creates != nil {
		if err := validateBatchScheduleActionCreateRequest(v.Creates); err != nil {
			invalidParams.AddNested("Creates", err.(smithy.InvalidParamsError))
		}
	}
	if v.Deletes != nil {
		if err := validateBatchScheduleActionDeleteRequest(v.Deletes); err != nil {
			invalidParams.AddNested("Deletes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateChannelInput(v *CreateChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateChannelInput"}
	if v.EncoderSettings != nil {
		if err := validateEncoderSettings(v.EncoderSettings); err != nil {
			invalidParams.AddNested("EncoderSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputAttachments != nil {
		if err := validate__listOfInputAttachment(v.InputAttachments); err != nil {
			invalidParams.AddNested("InputAttachments", err.(smithy.InvalidParamsError))
		}
	}
	if v.Vpc != nil {
		if err := validateVpcOutputSettings(v.Vpc); err != nil {
			invalidParams.AddNested("Vpc", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCreateCloudWatchAlarmTemplateInput(v *CreateCloudWatchAlarmTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCloudWatchAlarmTemplateInput"}
	if len(v.ComparisonOperator) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ComparisonOperator"))
	}
	if v.EvaluationPeriods == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EvaluationPeriods"))
	}
	if v.GroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupIdentifier"))
	}
	if v.MetricName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MetricName"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Period == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Period"))
	}
	if len(v.Statistic) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Statistic"))
	}
	if len(v.TargetResourceType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetResourceType"))
	}
	if v.Threshold == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Threshold"))
	}
	if len(v.TreatMissingData) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TreatMissingData"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateEventBridgeRuleTemplateInput(v *CreateEventBridgeRuleTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEventBridgeRuleTemplateInput"}
	if v.EventTargets != nil {
		if err := validate__listOfEventBridgeRuleTemplateTarget(v.EventTargets); err != nil {
			invalidParams.AddNested("EventTargets", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.EventType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EventType"))
	}
	if v.GroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateInputInput(v *CreateInputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateInputInput"}
	if v.Vpc != nil {
		if err := validateInputVpcRequest(v.Vpc); err != nil {
			invalidParams.AddNested("Vpc", err.(smithy.InvalidParamsError))
		}
	}
	if v.MulticastSettings != nil {
		if err := validateMulticastSettingsCreateRequest(v.MulticastSettings); err != nil {
			invalidParams.AddNested("MulticastSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMultiplexInput(v *CreateMultiplexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMultiplexInput"}
	if v.AvailabilityZones == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AvailabilityZones"))
	}
	if v.MultiplexSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexSettings"))
	} else if v.MultiplexSettings != nil {
		if err := validateMultiplexSettings(v.MultiplexSettings); err != nil {
			invalidParams.AddNested("MultiplexSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.RequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateMultiplexProgramInput(v *CreateMultiplexProgramInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateMultiplexProgramInput"}
	if v.MultiplexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexId"))
	}
	if v.MultiplexProgramSettings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexProgramSettings"))
	} else if v.MultiplexProgramSettings != nil {
		if err := validateMultiplexProgramSettings(v.MultiplexProgramSettings); err != nil {
			invalidParams.AddNested("MultiplexProgramSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProgramName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
	}
	if v.RequestId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpDeleteChannelPlacementGroupInput(v *DeleteChannelPlacementGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteChannelPlacementGroupInput"}
	if v.ChannelPlacementGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelPlacementGroupId"))
	}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpDeleteMultiplexProgramInput(v *DeleteMultiplexProgramInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteMultiplexProgramInput"}
	if v.MultiplexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexId"))
	}
	if v.ProgramName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteNodeInput(v *DeleteNodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteNodeInput"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if v.NodeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDescribeChannelPlacementGroupInput(v *DescribeChannelPlacementGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeChannelPlacementGroupInput"}
	if v.ChannelPlacementGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelPlacementGroupId"))
	}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeInputDeviceThumbnailInput(v *DescribeInputDeviceThumbnailInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeInputDeviceThumbnailInput"}
	if v.InputDeviceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputDeviceId"))
	}
	if len(v.Accept) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Accept"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDescribeMultiplexProgramInput(v *DescribeMultiplexProgramInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMultiplexProgramInput"}
	if v.MultiplexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexId"))
	}
	if v.ProgramName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDescribeNodeInput(v *DescribeNodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeNodeInput"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if v.NodeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDescribeThumbnailsInput(v *DescribeThumbnailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeThumbnailsInput"}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if v.PipelineId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PipelineId"))
	}
	if v.ThumbnailType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ThumbnailType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

func validateOpListNodesInput(v *ListNodesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListNodesInput"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	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 validateOpPurchaseOfferingInput(v *PurchaseOfferingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PurchaseOfferingInput"}
	if v.Count == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Count"))
	}
	if v.OfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpUpdateChannelClassInput(v *UpdateChannelClassInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelClassInput"}
	if len(v.ChannelClass) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelClass"))
	}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChannelInput(v *UpdateChannelInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelInput"}
	if v.ChannelId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelId"))
	}
	if v.EncoderSettings != nil {
		if err := validateEncoderSettings(v.EncoderSettings); err != nil {
			invalidParams.AddNested("EncoderSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.InputAttachments != nil {
		if err := validate__listOfInputAttachment(v.InputAttachments); err != nil {
			invalidParams.AddNested("InputAttachments", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateChannelPlacementGroupInput(v *UpdateChannelPlacementGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateChannelPlacementGroupInput"}
	if v.ChannelPlacementGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChannelPlacementGroupId"))
	}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpUpdateEventBridgeRuleTemplateInput(v *UpdateEventBridgeRuleTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEventBridgeRuleTemplateInput"}
	if v.EventTargets != nil {
		if err := validate__listOfEventBridgeRuleTemplateTarget(v.EventTargets); err != nil {
			invalidParams.AddNested("EventTargets", err.(smithy.InvalidParamsError))
		}
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateInputInput(v *UpdateInputInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateInputInput"}
	if v.InputId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("InputId"))
	}
	if v.MulticastSettings != nil {
		if err := validateMulticastSettingsUpdateRequest(v.MulticastSettings); err != nil {
			invalidParams.AddNested("MulticastSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateMultiplexInput(v *UpdateMultiplexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMultiplexInput"}
	if v.MultiplexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexId"))
	}
	if v.MultiplexSettings != nil {
		if err := validateMultiplexSettings(v.MultiplexSettings); err != nil {
			invalidParams.AddNested("MultiplexSettings", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateMultiplexProgramInput(v *UpdateMultiplexProgramInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateMultiplexProgramInput"}
	if v.MultiplexId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MultiplexId"))
	}
	if v.MultiplexProgramSettings != nil {
		if err := validateMultiplexProgramSettings(v.MultiplexProgramSettings); err != nil {
			invalidParams.AddNested("MultiplexProgramSettings", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProgramName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgramName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateNodeInput(v *UpdateNodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateNodeInput"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if v.NodeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateNodeStateInput(v *UpdateNodeStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateNodeStateInput"}
	if v.ClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterId"))
	}
	if v.NodeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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