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

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 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 addOpCreatePartnerInputValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreatePartnerInput{}, 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 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 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 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 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 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 addOpDescribeThumbnailsValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpDescribeThumbnails{}, 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 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 addOpStartChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartChannel{}, middleware.After)
}

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

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

func addOpStopChannelValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStopChannel{}, 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 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 addOpUpdateReservationValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateReservation{}, 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__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__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 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 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 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 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.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 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 validateDvbNitSettings(v *types.DvbNitSettings) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DvbNitSettings"}
	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 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 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.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 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.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 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.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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.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 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 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 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 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 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 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 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 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
	}
}