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

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 addOpCreateReportPlanValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpCreateReportPlan{}, 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 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 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 addOpGetRecoveryPointRestoreMetadataValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpGetRecoveryPointRestoreMetadata{}, 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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
	}
}