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

package backup

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

type validateOpAssociateBackupVaultMpaApprovalTeam struct {
}

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

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

type validateOpCancelLegalHold struct {
}

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

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

type validateOpCreateBackupPlan struct {
}

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

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

type validateOpCreateBackupSelection struct {
}

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

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

type validateOpCreateBackupVault struct {
}

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

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

type validateOpCreateFramework struct {
}

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

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

type validateOpCreateLegalHold struct {
}

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

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

type validateOpCreateLogicallyAirGappedBackupVault struct {
}

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

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

type validateOpCreateReportPlan struct {
}

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

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

type validateOpCreateRestoreAccessBackupVault struct {
}

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

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

type validateOpCreateRestoreTestingPlan struct {
}

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

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

type validateOpCreateRestoreTestingSelection struct {
}

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

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

type validateOpCreateTieringConfiguration struct {
}

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

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

type validateOpDeleteBackupPlan struct {
}

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

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

type validateOpDeleteBackupSelection struct {
}

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

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

type validateOpDeleteBackupVaultAccessPolicy struct {
}

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

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

type validateOpDeleteBackupVault struct {
}

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

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

type validateOpDeleteBackupVaultLockConfiguration struct {
}

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

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

type validateOpDeleteBackupVaultNotifications struct {
}

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

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

type validateOpDeleteFramework struct {
}

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

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

type validateOpDeleteRecoveryPoint struct {
}

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

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

type validateOpDeleteReportPlan struct {
}

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

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

type validateOpDeleteRestoreTestingPlan struct {
}

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

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

type validateOpDeleteRestoreTestingSelection struct {
}

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

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

type validateOpDeleteTieringConfiguration struct {
}

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

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

type validateOpDescribeBackupJob struct {
}

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

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

type validateOpDescribeBackupVault struct {
}

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

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

type validateOpDescribeCopyJob struct {
}

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

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

type validateOpDescribeFramework struct {
}

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

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

type validateOpDescribeProtectedResource struct {
}

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

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

type validateOpDescribeRecoveryPoint struct {
}

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

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

type validateOpDescribeReportJob struct {
}

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

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

type validateOpDescribeReportPlan struct {
}

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

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

type validateOpDescribeRestoreJob struct {
}

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

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

type validateOpDescribeScanJob struct {
}

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

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

type validateOpDisassociateBackupVaultMpaApprovalTeam struct {
}

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

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

type validateOpDisassociateRecoveryPointFromParent struct {
}

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

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

type validateOpDisassociateRecoveryPoint struct {
}

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

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

type validateOpExportBackupPlanTemplate struct {
}

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

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

type validateOpGetBackupPlanFromJSON struct {
}

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

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

type validateOpGetBackupPlanFromTemplate struct {
}

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

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

type validateOpGetBackupPlan struct {
}

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

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

type validateOpGetBackupSelection struct {
}

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

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

type validateOpGetBackupVaultAccessPolicy struct {
}

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

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

type validateOpGetBackupVaultNotifications struct {
}

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

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

type validateOpGetLegalHold struct {
}

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

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

type validateOpGetRecoveryPointIndexDetails struct {
}

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

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

type validateOpGetRecoveryPointRestoreMetadata struct {
}

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

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

type validateOpGetRestoreJobMetadata struct {
}

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

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

type validateOpGetRestoreTestingInferredMetadata struct {
}

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

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

type validateOpGetRestoreTestingPlan struct {
}

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

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

type validateOpGetRestoreTestingSelection struct {
}

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

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

type validateOpGetTieringConfiguration struct {
}

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

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

type validateOpListBackupPlanVersions struct {
}

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

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

type validateOpListBackupSelections struct {
}

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

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

type validateOpListProtectedResourcesByBackupVault struct {
}

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

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

type validateOpListRecoveryPointsByBackupVault struct {
}

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

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

type validateOpListRecoveryPointsByLegalHold struct {
}

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

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

type validateOpListRecoveryPointsByResource struct {
}

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

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

type validateOpListRestoreAccessBackupVaults struct {
}

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

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

type validateOpListRestoreJobsByProtectedResource struct {
}

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

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

type validateOpListRestoreTestingSelections struct {
}

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

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

type validateOpListTags struct {
}

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

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

type validateOpPutBackupVaultAccessPolicy struct {
}

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

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

type validateOpPutBackupVaultLockConfiguration struct {
}

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

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

type validateOpPutBackupVaultNotifications struct {
}

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

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

type validateOpPutRestoreValidationResult struct {
}

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

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

type validateOpRevokeRestoreAccessBackupVault struct {
}

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

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

type validateOpStartBackupJob struct {
}

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

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

type validateOpStartCopyJob struct {
}

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

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

type validateOpStartReportJob struct {
}

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

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

type validateOpStartRestoreJob struct {
}

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

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

type validateOpStartScanJob struct {
}

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

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

type validateOpStopBackupJob struct {
}

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

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

type validateOpTagResource struct {
}

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

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

type validateOpUntagResource struct {
}

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

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

type validateOpUpdateBackupPlan struct {
}

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

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

type validateOpUpdateFramework struct {
}

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

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

type validateOpUpdateRecoveryPointIndexSettings struct {
}

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

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

type validateOpUpdateRecoveryPointLifecycle struct {
}

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

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

type validateOpUpdateReportPlan struct {
}

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

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

type validateOpUpdateRestoreTestingPlan struct {
}

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

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

type validateOpUpdateRestoreTestingSelection struct {
}

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

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

type validateOpUpdateTieringConfiguration struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateBackupPlanInput(v *types.BackupPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BackupPlanInput"}
	if v.BackupPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanName"))
	}
	if v.Rules == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Rules"))
	} else if v.Rules != nil {
		if err := validateBackupRulesInput(v.Rules); err != nil {
			invalidParams.AddNested("Rules", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBackupRuleInput(v *types.BackupRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BackupRuleInput"}
	if v.RuleName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RuleName"))
	}
	if v.TargetBackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetBackupVaultName"))
	}
	if v.CopyActions != nil {
		if err := validateCopyActions(v.CopyActions); err != nil {
			invalidParams.AddNested("CopyActions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBackupSelection(v *types.BackupSelection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BackupSelection"}
	if v.SelectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionName"))
	}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if v.ListOfTags != nil {
		if err := validateListOfTags(v.ListOfTags); err != nil {
			invalidParams.AddNested("ListOfTags", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateCondition(v *types.Condition) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "Condition"}
	if len(v.ConditionType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionType"))
	}
	if v.ConditionKey == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionKey"))
	}
	if v.ConditionValue == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConditionValue"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateDateRange(v *types.DateRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DateRange"}
	if v.FromDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FromDate"))
	}
	if v.ToDate == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ToDate"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateKeyValue(v *types.KeyValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "KeyValue"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateProtectedResourceConditions(v *types.ProtectedResourceConditions) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProtectedResourceConditions"}
	if v.StringEquals != nil {
		if err := validateKeyValueList(v.StringEquals); err != nil {
			invalidParams.AddNested("StringEquals", err.(smithy.InvalidParamsError))
		}
	}
	if v.StringNotEquals != nil {
		if err := validateKeyValueList(v.StringNotEquals); err != nil {
			invalidParams.AddNested("StringNotEquals", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRecoveryPointSelection(v *types.RecoveryPointSelection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RecoveryPointSelection"}
	if v.DateRange != nil {
		if err := validateDateRange(v.DateRange); err != nil {
			invalidParams.AddNested("DateRange", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateResourceSelection(v *types.ResourceSelection) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceSelection"}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	}
	if v.TieringDownSettingsInDays == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TieringDownSettingsInDays"))
	}
	if v.ResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRestoreTestingPlanForCreate(v *types.RestoreTestingPlanForCreate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreTestingPlanForCreate"}
	if v.RecoveryPointSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointSelection"))
	}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if v.ScheduleExpression == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScheduleExpression"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRestoreTestingSelectionForCreate(v *types.RestoreTestingSelectionForCreate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreTestingSelectionForCreate"}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if v.ProtectedResourceConditions != nil {
		if err := validateProtectedResourceConditions(v.ProtectedResourceConditions); err != nil {
			invalidParams.AddNested("ProtectedResourceConditions", err.(smithy.InvalidParamsError))
		}
	}
	if v.ProtectedResourceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProtectedResourceType"))
	}
	if v.RestoreTestingSelectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelectionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRestoreTestingSelectionForUpdate(v *types.RestoreTestingSelectionForUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RestoreTestingSelectionForUpdate"}
	if v.ProtectedResourceConditions != nil {
		if err := validateProtectedResourceConditions(v.ProtectedResourceConditions); err != nil {
			invalidParams.AddNested("ProtectedResourceConditions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTieringConfigurationInputForCreate(v *types.TieringConfigurationInputForCreate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TieringConfigurationInputForCreate"}
	if v.TieringConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TieringConfigurationName"))
	}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.ResourceSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSelection"))
	} else if v.ResourceSelection != nil {
		if err := validateResourceSelections(v.ResourceSelection); err != nil {
			invalidParams.AddNested("ResourceSelection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTieringConfigurationInputForUpdate(v *types.TieringConfigurationInputForUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TieringConfigurationInputForUpdate"}
	if v.ResourceSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSelection"))
	} else if v.ResourceSelection != nil {
		if err := validateResourceSelections(v.ResourceSelection); err != nil {
			invalidParams.AddNested("ResourceSelection", err.(smithy.InvalidParamsError))
		}
	}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateBackupVaultMpaApprovalTeamInput(v *AssociateBackupVaultMpaApprovalTeamInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateBackupVaultMpaApprovalTeamInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.MpaApprovalTeamArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MpaApprovalTeamArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelLegalHoldInput(v *CancelLegalHoldInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelLegalHoldInput"}
	if v.LegalHoldId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LegalHoldId"))
	}
	if v.CancelDescription == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CancelDescription"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBackupPlanInput(v *CreateBackupPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupPlanInput"}
	if v.BackupPlan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlan"))
	} else if v.BackupPlan != nil {
		if err := validateBackupPlanInput(v.BackupPlan); err != nil {
			invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateBackupSelectionInput(v *CreateBackupSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateBackupSelectionInput"}
	if v.BackupPlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
	}
	if v.BackupSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupSelection"))
	} else if v.BackupSelection != nil {
		if err := validateBackupSelection(v.BackupSelection); err != nil {
			invalidParams.AddNested("BackupSelection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFrameworkInput(v *CreateFrameworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFrameworkInput"}
	if v.FrameworkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
	}
	if v.FrameworkControls == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkControls"))
	} else if v.FrameworkControls != nil {
		if err := validateFrameworkControls(v.FrameworkControls); err != nil {
			invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLegalHoldInput(v *CreateLegalHoldInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLegalHoldInput"}
	if v.Title == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Title"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if v.RecoveryPointSelection != nil {
		if err := validateRecoveryPointSelection(v.RecoveryPointSelection); err != nil {
			invalidParams.AddNested("RecoveryPointSelection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateLogicallyAirGappedBackupVaultInput(v *CreateLogicallyAirGappedBackupVaultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateLogicallyAirGappedBackupVaultInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.MinRetentionDays == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinRetentionDays"))
	}
	if v.MaxRetentionDays == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MaxRetentionDays"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateReportPlanInput(v *CreateReportPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReportPlanInput"}
	if v.ReportPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
	}
	if v.ReportDeliveryChannel == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportDeliveryChannel"))
	} else if v.ReportDeliveryChannel != nil {
		if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil {
			invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReportSetting == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportSetting"))
	} else if v.ReportSetting != nil {
		if err := validateReportSetting(v.ReportSetting); err != nil {
			invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateRestoreTestingPlanInput(v *CreateRestoreTestingPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRestoreTestingPlanInput"}
	if v.RestoreTestingPlan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlan"))
	} else if v.RestoreTestingPlan != nil {
		if err := validateRestoreTestingPlanForCreate(v.RestoreTestingPlan); err != nil {
			invalidParams.AddNested("RestoreTestingPlan", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRestoreTestingSelectionInput(v *CreateRestoreTestingSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRestoreTestingSelectionInput"}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if v.RestoreTestingSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelection"))
	} else if v.RestoreTestingSelection != nil {
		if err := validateRestoreTestingSelectionForCreate(v.RestoreTestingSelection); err != nil {
			invalidParams.AddNested("RestoreTestingSelection", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateTieringConfigurationInput(v *CreateTieringConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTieringConfigurationInput"}
	if v.TieringConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TieringConfiguration"))
	} else if v.TieringConfiguration != nil {
		if err := validateTieringConfigurationInputForCreate(v.TieringConfiguration); err != nil {
			invalidParams.AddNested("TieringConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteBackupSelectionInput(v *DeleteBackupSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteBackupSelectionInput"}
	if v.BackupPlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
	}
	if v.SelectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDeleteRecoveryPointInput(v *DeleteRecoveryPointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRecoveryPointInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteRestoreTestingSelectionInput(v *DeleteRestoreTestingSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRestoreTestingSelectionInput"}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if v.RestoreTestingSelectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelectionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateOpDescribeRecoveryPointInput(v *DescribeRecoveryPointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeRecoveryPointInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpDisassociateRecoveryPointFromParentInput(v *DisassociateRecoveryPointFromParentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRecoveryPointFromParentInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateRecoveryPointInput(v *DisassociateRecoveryPointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateRecoveryPointInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpGetBackupSelectionInput(v *GetBackupSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetBackupSelectionInput"}
	if v.BackupPlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
	}
	if v.SelectionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SelectionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpGetRecoveryPointIndexDetailsInput(v *GetRecoveryPointIndexDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRecoveryPointIndexDetailsInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRecoveryPointRestoreMetadataInput(v *GetRecoveryPointRestoreMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRecoveryPointRestoreMetadataInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetRestoreTestingInferredMetadataInput(v *GetRestoreTestingInferredMetadataInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRestoreTestingInferredMetadataInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetRestoreTestingSelectionInput(v *GetRestoreTestingSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRestoreTestingSelectionInput"}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if v.RestoreTestingSelectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelectionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpPutBackupVaultNotificationsInput(v *PutBackupVaultNotificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutBackupVaultNotificationsInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.SNSTopicArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SNSTopicArn"))
	}
	if v.BackupVaultEvents == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultEvents"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutRestoreValidationResultInput(v *PutRestoreValidationResultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutRestoreValidationResultInput"}
	if v.RestoreJobId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreJobId"))
	}
	if len(v.ValidationStatus) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ValidationStatus"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeRestoreAccessBackupVaultInput(v *RevokeRestoreAccessBackupVaultInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeRestoreAccessBackupVaultInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RestoreAccessBackupVaultArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreAccessBackupVaultArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartCopyJobInput(v *StartCopyJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartCopyJobInput"}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if v.SourceBackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceBackupVaultName"))
	}
	if v.DestinationBackupVaultArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DestinationBackupVaultArn"))
	}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartRestoreJobInput(v *StartRestoreJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRestoreJobInput"}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if v.Metadata == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Metadata"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartScanJobInput(v *StartScanJobInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartScanJobInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.IamRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IamRoleArn"))
	}
	if len(v.MalwareScanner) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("MalwareScanner"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if len(v.ScanMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ScanMode"))
	}
	if v.ScannerRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ScannerRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateBackupPlanInput(v *UpdateBackupPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateBackupPlanInput"}
	if v.BackupPlanId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlanId"))
	}
	if v.BackupPlan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupPlan"))
	} else if v.BackupPlan != nil {
		if err := validateBackupPlanInput(v.BackupPlan); err != nil {
			invalidParams.AddNested("BackupPlan", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateFrameworkInput(v *UpdateFrameworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFrameworkInput"}
	if v.FrameworkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FrameworkName"))
	}
	if v.FrameworkControls != nil {
		if err := validateFrameworkControls(v.FrameworkControls); err != nil {
			invalidParams.AddNested("FrameworkControls", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRecoveryPointIndexSettingsInput(v *UpdateRecoveryPointIndexSettingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecoveryPointIndexSettingsInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if len(v.Index) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Index"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRecoveryPointLifecycleInput(v *UpdateRecoveryPointLifecycleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecoveryPointLifecycleInput"}
	if v.BackupVaultName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("BackupVaultName"))
	}
	if v.RecoveryPointArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryPointArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateReportPlanInput(v *UpdateReportPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReportPlanInput"}
	if v.ReportPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReportPlanName"))
	}
	if v.ReportDeliveryChannel != nil {
		if err := validateReportDeliveryChannel(v.ReportDeliveryChannel); err != nil {
			invalidParams.AddNested("ReportDeliveryChannel", err.(smithy.InvalidParamsError))
		}
	}
	if v.ReportSetting != nil {
		if err := validateReportSetting(v.ReportSetting); err != nil {
			invalidParams.AddNested("ReportSetting", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRestoreTestingPlanInput(v *UpdateRestoreTestingPlanInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRestoreTestingPlanInput"}
	if v.RestoreTestingPlan == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlan"))
	}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRestoreTestingSelectionInput(v *UpdateRestoreTestingSelectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRestoreTestingSelectionInput"}
	if v.RestoreTestingPlanName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingPlanName"))
	}
	if v.RestoreTestingSelection == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelection"))
	} else if v.RestoreTestingSelection != nil {
		if err := validateRestoreTestingSelectionForUpdate(v.RestoreTestingSelection); err != nil {
			invalidParams.AddNested("RestoreTestingSelection", err.(smithy.InvalidParamsError))
		}
	}
	if v.RestoreTestingSelectionName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RestoreTestingSelectionName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateTieringConfigurationInput(v *UpdateTieringConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTieringConfigurationInput"}
	if v.TieringConfigurationName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TieringConfigurationName"))
	}
	if v.TieringConfiguration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TieringConfiguration"))
	} else if v.TieringConfiguration != nil {
		if err := validateTieringConfigurationInputForUpdate(v.TieringConfiguration); err != nil {
			invalidParams.AddNested("TieringConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}
