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

package elasticache

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

type validateOpAddTagsToResource struct {
}

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

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

type validateOpAuthorizeCacheSecurityGroupIngress struct {
}

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

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

type validateOpBatchApplyUpdateAction struct {
}

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

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

type validateOpBatchStopUpdateAction struct {
}

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

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

type validateOpCompleteMigration struct {
}

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

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

type validateOpCopyServerlessCacheSnapshot struct {
}

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

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

type validateOpCopySnapshot struct {
}

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

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

type validateOpCreateCacheCluster struct {
}

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

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

type validateOpCreateCacheParameterGroup struct {
}

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

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

type validateOpCreateCacheSecurityGroup struct {
}

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

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

type validateOpCreateCacheSubnetGroup struct {
}

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

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

type validateOpCreateGlobalReplicationGroup struct {
}

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

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

type validateOpCreateReplicationGroup struct {
}

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

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

type validateOpCreateServerlessCache struct {
}

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

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

type validateOpCreateServerlessCacheSnapshot struct {
}

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

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

type validateOpCreateSnapshot struct {
}

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

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

type validateOpCreateUserGroup struct {
}

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

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

type validateOpCreateUser struct {
}

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

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

type validateOpDecreaseNodeGroupsInGlobalReplicationGroup struct {
}

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

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

type validateOpDecreaseReplicaCount struct {
}

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

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

type validateOpDeleteCacheCluster struct {
}

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

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

type validateOpDeleteCacheParameterGroup struct {
}

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

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

type validateOpDeleteCacheSecurityGroup struct {
}

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

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

type validateOpDeleteCacheSubnetGroup struct {
}

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

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

type validateOpDeleteGlobalReplicationGroup struct {
}

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

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

type validateOpDeleteReplicationGroup struct {
}

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

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

type validateOpDeleteServerlessCache struct {
}

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

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

type validateOpDeleteServerlessCacheSnapshot struct {
}

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

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

type validateOpDeleteSnapshot struct {
}

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

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

type validateOpDeleteUserGroup struct {
}

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

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

type validateOpDeleteUser struct {
}

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

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

type validateOpDescribeCacheParameters struct {
}

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

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

type validateOpDescribeEngineDefaultParameters struct {
}

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

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

type validateOpDescribeUsers struct {
}

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

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

type validateOpDisassociateGlobalReplicationGroup struct {
}

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

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

type validateOpExportServerlessCacheSnapshot struct {
}

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

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

type validateOpFailoverGlobalReplicationGroup struct {
}

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

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

type validateOpIncreaseNodeGroupsInGlobalReplicationGroup struct {
}

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

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

type validateOpIncreaseReplicaCount struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpModifyCacheCluster struct {
}

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

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

type validateOpModifyCacheParameterGroup struct {
}

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

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

type validateOpModifyCacheSubnetGroup struct {
}

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

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

type validateOpModifyGlobalReplicationGroup struct {
}

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

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

type validateOpModifyReplicationGroup struct {
}

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

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

type validateOpModifyReplicationGroupShardConfiguration struct {
}

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

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

type validateOpModifyServerlessCache struct {
}

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

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

type validateOpModifyUserGroup struct {
}

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

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

type validateOpModifyUser struct {
}

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

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

type validateOpPurchaseReservedCacheNodesOffering struct {
}

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

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

type validateOpRebalanceSlotsInGlobalReplicationGroup struct {
}

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

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

type validateOpRebootCacheCluster struct {
}

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

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

type validateOpRemoveTagsFromResource struct {
}

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

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

type validateOpResetCacheParameterGroup struct {
}

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

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

type validateOpRevokeCacheSecurityGroupIngress struct {
}

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

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

type validateOpStartMigration struct {
}

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

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

type validateOpTestFailover struct {
}

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

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

type validateOpTestMigration struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateCacheUsageLimits(v *types.CacheUsageLimits) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CacheUsageLimits"}
	if v.DataStorage != nil {
		if err := validateDataStorage(v.DataStorage); err != nil {
			invalidParams.AddNested("DataStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConfigureShard(v *types.ConfigureShard) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConfigureShard"}
	if v.NodeGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupId"))
	}
	if v.NewReplicaCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NewReplicaCount"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateRegionalConfiguration(v *types.RegionalConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RegionalConfiguration"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.ReplicationGroupRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupRegion"))
	}
	if v.ReshardingConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReshardingConfiguration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAddTagsToResourceInput(v *AddTagsToResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddTagsToResourceInput"}
	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 validateOpAuthorizeCacheSecurityGroupIngressInput(v *AuthorizeCacheSecurityGroupIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AuthorizeCacheSecurityGroupIngressInput"}
	if v.CacheSecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
	}
	if v.EC2SecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupName"))
	}
	if v.EC2SecurityGroupOwnerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupOwnerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpCopyServerlessCacheSnapshotInput(v *CopyServerlessCacheSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopyServerlessCacheSnapshotInput"}
	if v.SourceServerlessCacheSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceServerlessCacheSnapshotName"))
	}
	if v.TargetServerlessCacheSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetServerlessCacheSnapshotName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCopySnapshotInput(v *CopySnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CopySnapshotInput"}
	if v.SourceSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceSnapshotName"))
	}
	if v.TargetSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetSnapshotName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateCacheParameterGroupInput(v *CreateCacheParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheParameterGroupInput"}
	if v.CacheParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
	}
	if v.CacheParameterGroupFamily == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupFamily"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateCacheSubnetGroupInput(v *CreateCacheSubnetGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateCacheSubnetGroupInput"}
	if v.CacheSubnetGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupName"))
	}
	if v.CacheSubnetGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheSubnetGroupDescription"))
	}
	if v.SubnetIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubnetIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGlobalReplicationGroupInput(v *CreateGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupIdSuffix == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupIdSuffix"))
	}
	if v.PrimaryReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryReplicationGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReplicationGroupInput(v *CreateReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationGroupInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.ReplicationGroupDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateServerlessCacheInput(v *CreateServerlessCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServerlessCacheInput"}
	if v.ServerlessCacheName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerlessCacheName"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.CacheUsageLimits != nil {
		if err := validateCacheUsageLimits(v.CacheUsageLimits); err != nil {
			invalidParams.AddNested("CacheUsageLimits", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateServerlessCacheSnapshotInput(v *CreateServerlessCacheSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateServerlessCacheSnapshotInput"}
	if v.ServerlessCacheSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerlessCacheSnapshotName"))
	}
	if v.ServerlessCacheName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerlessCacheName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateUserGroupInput(v *CreateUserGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserGroupInput"}
	if v.UserGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserGroupId"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserInput(v *CreateUserInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserInput"}
	if v.UserId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserId"))
	}
	if v.UserName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserName"))
	}
	if v.Engine == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Engine"))
	}
	if v.AccessString == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AccessString"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDecreaseNodeGroupsInGlobalReplicationGroupInput(v *DecreaseNodeGroupsInGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecreaseNodeGroupsInGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.NodeGroupCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupCount"))
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDecreaseReplicaCountInput(v *DecreaseReplicaCountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DecreaseReplicaCountInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.ReplicaConfiguration != nil {
		if err := validateReplicaConfigurationList(v.ReplicaConfiguration); err != nil {
			invalidParams.AddNested("ReplicaConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpDeleteGlobalReplicationGroupInput(v *DeleteGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.RetainPrimaryReplicationGroup == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetainPrimaryReplicationGroup"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpDisassociateGlobalReplicationGroupInput(v *DisassociateGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.ReplicationGroupRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpExportServerlessCacheSnapshotInput(v *ExportServerlessCacheSnapshotInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ExportServerlessCacheSnapshotInput"}
	if v.ServerlessCacheSnapshotName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerlessCacheSnapshotName"))
	}
	if v.S3BucketName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("S3BucketName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpFailoverGlobalReplicationGroupInput(v *FailoverGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FailoverGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.PrimaryRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryRegion"))
	}
	if v.PrimaryReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PrimaryReplicationGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpIncreaseNodeGroupsInGlobalReplicationGroupInput(v *IncreaseNodeGroupsInGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IncreaseNodeGroupsInGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.NodeGroupCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupCount"))
	}
	if v.RegionalConfigurations != nil {
		if err := validateRegionalConfigurationList(v.RegionalConfigurations); err != nil {
			invalidParams.AddNested("RegionalConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpIncreaseReplicaCountInput(v *IncreaseReplicaCountInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "IncreaseReplicaCountInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.ReplicaConfiguration != nil {
		if err := validateReplicaConfigurationList(v.ReplicaConfiguration); err != nil {
			invalidParams.AddNested("ReplicaConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpModifyCacheParameterGroupInput(v *ModifyCacheParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyCacheParameterGroupInput"}
	if v.CacheParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
	}
	if v.ParameterNameValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParameterNameValues"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyGlobalReplicationGroupInput(v *ModifyGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpModifyReplicationGroupShardConfigurationInput(v *ModifyReplicationGroupShardConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyReplicationGroupShardConfigurationInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.NodeGroupCount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupCount"))
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpModifyServerlessCacheInput(v *ModifyServerlessCacheInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ModifyServerlessCacheInput"}
	if v.ServerlessCacheName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ServerlessCacheName"))
	}
	if v.CacheUsageLimits != nil {
		if err := validateCacheUsageLimits(v.CacheUsageLimits); err != nil {
			invalidParams.AddNested("CacheUsageLimits", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpRebalanceSlotsInGlobalReplicationGroupInput(v *RebalanceSlotsInGlobalReplicationGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RebalanceSlotsInGlobalReplicationGroupInput"}
	if v.GlobalReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlobalReplicationGroupId"))
	}
	if v.ApplyImmediately == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplyImmediately"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRebootCacheClusterInput(v *RebootCacheClusterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RebootCacheClusterInput"}
	if v.CacheClusterId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheClusterId"))
	}
	if v.CacheNodeIdsToReboot == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheNodeIdsToReboot"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveTagsFromResourceInput(v *RemoveTagsFromResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveTagsFromResourceInput"}
	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 validateOpResetCacheParameterGroupInput(v *ResetCacheParameterGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResetCacheParameterGroupInput"}
	if v.CacheParameterGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheParameterGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeCacheSecurityGroupIngressInput(v *RevokeCacheSecurityGroupIngressInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeCacheSecurityGroupIngressInput"}
	if v.CacheSecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CacheSecurityGroupName"))
	}
	if v.EC2SecurityGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupName"))
	}
	if v.EC2SecurityGroupOwnerId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EC2SecurityGroupOwnerId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMigrationInput(v *StartMigrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMigrationInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.CustomerNodeEndpointList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerNodeEndpointList"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestFailoverInput(v *TestFailoverInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestFailoverInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.NodeGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("NodeGroupId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpTestMigrationInput(v *TestMigrationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TestMigrationInput"}
	if v.ReplicationGroupId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationGroupId"))
	}
	if v.CustomerNodeEndpointList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CustomerNodeEndpointList"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}