validators.go

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

package redshift

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

type validateOpAcceptReservedNodeExchange struct {
}

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

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

type validateOpAddPartner struct {
}

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

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

type validateOpAuthorizeClusterSecurityGroupIngress struct {
}

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

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

type validateOpAuthorizeEndpointAccess struct {
}

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

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

type validateOpAuthorizeSnapshotAccess struct {
}

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

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

type validateOpBatchDeleteClusterSnapshots struct {
}

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

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

type validateOpBatchModifyClusterSnapshots struct {
}

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

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

type validateOpCancelResize struct {
}

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

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

type validateOpCopyClusterSnapshot struct {
}

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

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

type validateOpCreateCluster struct {
}

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

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

type validateOpCreateClusterParameterGroup struct {
}

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

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

type validateOpCreateClusterSecurityGroup struct {
}

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

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

type validateOpCreateClusterSnapshot struct {
}

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

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

type validateOpCreateClusterSubnetGroup struct {
}

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

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

type validateOpCreateEndpointAccess struct {
}

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

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

type validateOpCreateEventSubscription struct {
}

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

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

type validateOpCreateHsmClientCertificate struct {
}

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

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

type validateOpCreateHsmConfiguration struct {
}

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

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

type validateOpCreateScheduledAction struct {
}

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

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

type validateOpCreateSnapshotCopyGrant struct {
}

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

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

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

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

type validateOpDeleteCluster struct {
}

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

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

type validateOpDeleteClusterParameterGroup struct {
}

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

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

type validateOpDeleteClusterSecurityGroup struct {
}

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

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

type validateOpDeleteClusterSnapshot struct {
}

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

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

type validateOpDeleteClusterSubnetGroup struct {
}

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

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

type validateOpDeleteEndpointAccess struct {
}

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

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

type validateOpDeleteEventSubscription struct {
}

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

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

type validateOpDeleteHsmClientCertificate struct {
}

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

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

type validateOpDeleteHsmConfiguration struct {
}

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

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

type validateOpDeletePartner struct {
}

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

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

type validateOpDeleteScheduledAction struct {
}

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

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

type validateOpDeleteSnapshotCopyGrant struct {
}

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

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

type validateOpDeleteSnapshotSchedule struct {
}

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

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

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

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

type validateOpDescribeClusterParameters struct {
}

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

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

type validateOpDescribeClusterSnapshots struct {
}

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

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

type validateOpDescribeDefaultClusterParameters struct {
}

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

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

type validateOpDescribeLoggingStatus struct {
}

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

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

type validateOpDescribeNodeConfigurationOptions struct {
}

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

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

type validateOpDescribePartners struct {
}

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

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

type validateOpDescribeResize struct {
}

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

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

type validateOpDescribeScheduledActions struct {
}

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

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

type validateOpDisableLogging struct {
}

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

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

type validateOpDisableSnapshotCopy struct {
}

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

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

type validateOpEnableLogging struct {
}

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

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

type validateOpEnableSnapshotCopy struct {
}

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

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

type validateOpGetClusterCredentials struct {
}

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

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

type validateOpGetReservedNodeExchangeOfferings struct {
}

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

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

type validateOpModifyAquaConfiguration struct {
}

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

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

type validateOpModifyClusterDbRevision struct {
}

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

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

type validateOpModifyClusterIamRoles struct {
}

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

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

type validateOpModifyCluster struct {
}

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

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

type validateOpModifyClusterMaintenance struct {
}

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

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

type validateOpModifyClusterParameterGroup struct {
}

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

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

type validateOpModifyClusterSnapshot struct {
}

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

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

type validateOpModifyClusterSnapshotSchedule struct {
}

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

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

type validateOpModifyClusterSubnetGroup struct {
}

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

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

type validateOpModifyEndpointAccess struct {
}

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

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

type validateOpModifyEventSubscription struct {
}

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

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

type validateOpModifyScheduledAction struct {
}

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

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

type validateOpModifySnapshotCopyRetentionPeriod struct {
}

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

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

type validateOpModifySnapshotSchedule struct {
}

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

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

type validateOpModifyUsageLimit struct {
}

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

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

type validateOpPauseCluster struct {
}

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

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

type validateOpPurchaseReservedNodeOffering struct {
}

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

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

type validateOpRebootCluster struct {
}

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

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

type validateOpResetClusterParameterGroup struct {
}

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

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

type validateOpResizeCluster struct {
}

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

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

type validateOpRestoreFromClusterSnapshot struct {
}

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

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

type validateOpRestoreTableFromClusterSnapshot struct {
}

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

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

type validateOpResumeCluster struct {
}

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

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

type validateOpRevokeClusterSecurityGroupIngress struct {
}

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

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

type validateOpRevokeSnapshotAccess struct {
}

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

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

type validateOpRotateEncryptionKey struct {
}

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

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

type validateOpUpdatePartnerStatus struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateScheduledActionFilter(v *types.ScheduledActionFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionFilter"}
	if len(v.Name) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateScheduledActionType(v *types.ScheduledActionType) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ScheduledActionType"}
	if v.ResizeCluster != nil {
		if err := validateResizeClusterMessage(v.ResizeCluster); err != nil {
			invalidParams.AddNested("ResizeCluster", err.(smithy.InvalidParamsError))
		}
	}
	if v.PauseCluster != nil {
		if err := validatePauseClusterMessage(v.PauseCluster); err != nil {
			invalidParams.AddNested("PauseCluster", err.(smithy.InvalidParamsError))
		}
	}
	if v.ResumeCluster != nil {
		if err := validateResumeClusterMessage(v.ResumeCluster); err != nil {
			invalidParams.AddNested("ResumeCluster", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAcceptReservedNodeExchangeInput(v *AcceptReservedNodeExchangeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptReservedNodeExchangeInput"}
	if v.ReservedNodeId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReservedNodeId"))
	}
	if v.TargetReservedNodeOfferingId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReservedNodeOfferingId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddPartnerInput(v *AddPartnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddPartnerInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.PartnerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAuthorizeSnapshotAccessInput(v *AuthorizeSnapshotAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeSnapshotAccessInput"}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if v.AccountWithRestoreAccess == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchDeleteClusterSnapshotsInput(v *BatchDeleteClusterSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDeleteClusterSnapshotsInput"}
	if v.Identifiers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifiers"))
	} else if v.Identifiers != nil {
		if err := validateDeleteClusterSnapshotMessageList(v.Identifiers); err != nil {
			invalidParams.AddNested("Identifiers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpCopyClusterSnapshotInput(v *CopyClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyClusterSnapshotInput"}
	if v.SourceSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotIdentifier"))
	}
	if v.TargetSnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterInput(v *CreateClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.NodeType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeType"))
	}
	if v.MasterUsername == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUsername"))
	}
	if v.MasterUserPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MasterUserPassword"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterParameterGroupInput(v *CreateClusterParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterParameterGroupInput"}
	if v.ParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
	}
	if v.ParameterGroupFamily == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupFamily"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterSecurityGroupInput(v *CreateClusterSecurityGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSecurityGroupInput"}
	if v.ClusterSecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterSecurityGroupName"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterSnapshotInput(v *CreateClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSnapshotInput"}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateClusterSubnetGroupInput(v *CreateClusterSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateClusterSubnetGroupInput"}
	if v.ClusterSubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterSubnetGroupName"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEndpointAccessInput(v *CreateEndpointAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEndpointAccessInput"}
	if v.EndpointName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EndpointName"))
	}
	if v.SubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEventSubscriptionInput(v *CreateEventSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEventSubscriptionInput"}
	if v.SubscriptionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionName"))
	}
	if v.SnsTopicArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnsTopicArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateHsmConfigurationInput(v *CreateHsmConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateHsmConfigurationInput"}
	if v.HsmConfigurationIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HsmConfigurationIdentifier"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.HsmIpAddress == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HsmIpAddress"))
	}
	if v.HsmPartitionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionName"))
	}
	if v.HsmPartitionPassword == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HsmPartitionPassword"))
	}
	if v.HsmServerPublicCertificate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("HsmServerPublicCertificate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateScheduledActionInput(v *CreateScheduledActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateScheduledActionInput"}
	if v.ScheduledActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
	}
	if v.TargetAction == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetAction"))
	} else if v.TargetAction != nil {
		if err := validateScheduledActionType(v.TargetAction); err != nil {
			invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError))
		}
	}
	if v.Schedule == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Schedule"))
	}
	if v.IamRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRole"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateUsageLimitInput(v *CreateUsageLimitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUsageLimitInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if len(v.FeatureType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("FeatureType"))
	}
	if len(v.LimitType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("LimitType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpDeletePartnerInput(v *DeletePartnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeletePartnerInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.PartnerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDescribeClusterSnapshotsInput(v *DescribeClusterSnapshotsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeClusterSnapshotsInput"}
	if v.SortingEntities != nil {
		if err := validateSnapshotSortingEntityList(v.SortingEntities); err != nil {
			invalidParams.AddNested("SortingEntities", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDescribeNodeConfigurationOptionsInput(v *DescribeNodeConfigurationOptionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeNodeConfigurationOptionsInput"}
	if len(v.ActionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ActionType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDescribePartnersInput(v *DescribePartnersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribePartnersInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpEnableLoggingInput(v *EnableLoggingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableLoggingInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BucketName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpEnableSnapshotCopyInput(v *EnableSnapshotCopyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnableSnapshotCopyInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.DestinationRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetClusterCredentialsInput(v *GetClusterCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetClusterCredentialsInput"}
	if v.DbUser == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DbUser"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyClusterDbRevisionInput(v *ModifyClusterDbRevisionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterDbRevisionInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.RevisionTarget == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RevisionTarget"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpModifyClusterParameterGroupInput(v *ModifyClusterParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyClusterParameterGroupInput"}
	if v.ParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterGroupName"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpModifyScheduledActionInput(v *ModifyScheduledActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyScheduledActionInput"}
	if v.ScheduledActionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduledActionName"))
	}
	if v.TargetAction != nil {
		if err := validateScheduledActionType(v.TargetAction); err != nil {
			invalidParams.AddNested("TargetAction", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifySnapshotScheduleInput(v *ModifySnapshotScheduleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifySnapshotScheduleInput"}
	if v.ScheduleIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleIdentifier"))
	}
	if v.ScheduleDefinitions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleDefinitions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpRestoreFromClusterSnapshotInput(v *RestoreFromClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreFromClusterSnapshotInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRestoreTableFromClusterSnapshotInput(v *RestoreTableFromClusterSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreTableFromClusterSnapshotInput"}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if v.SourceDatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceDatabaseName"))
	}
	if v.SourceTableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceTableName"))
	}
	if v.NewTableName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewTableName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpRevokeSnapshotAccessInput(v *RevokeSnapshotAccessInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeSnapshotAccessInput"}
	if v.SnapshotIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SnapshotIdentifier"))
	}
	if v.AccountWithRestoreAccess == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountWithRestoreAccess"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdatePartnerStatusInput(v *UpdatePartnerStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdatePartnerStatusInput"}
	if v.AccountId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccountId"))
	}
	if v.ClusterIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ClusterIdentifier"))
	}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.PartnerName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PartnerName"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}