validators.go

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

package drs

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

type validateOpAssociateSourceNetworkStack struct {
}

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

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

type validateOpCreateExtendedSourceServer struct {
}

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

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

type validateOpCreateReplicationConfigurationTemplate struct {
}

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

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

type validateOpCreateSourceNetwork struct {
}

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

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

type validateOpDeleteJob struct {
}

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

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

type validateOpDeleteLaunchAction struct {
}

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

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

type validateOpDeleteLaunchConfigurationTemplate struct {
}

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

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

type validateOpDeleteRecoveryInstance struct {
}

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

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

type validateOpDeleteReplicationConfigurationTemplate struct {
}

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

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

type validateOpDeleteSourceNetwork struct {
}

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

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

type validateOpDeleteSourceServer struct {
}

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

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

type validateOpDescribeJobLogItems struct {
}

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

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

type validateOpDescribeRecoverySnapshots struct {
}

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

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

type validateOpDisconnectRecoveryInstance struct {
}

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

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

type validateOpDisconnectSourceServer struct {
}

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

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

type validateOpExportSourceNetworkCfnTemplate struct {
}

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

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

type validateOpGetFailbackReplicationConfiguration struct {
}

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

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

type validateOpGetLaunchConfiguration struct {
}

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

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

type validateOpGetReplicationConfiguration struct {
}

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

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

type validateOpListExtensibleSourceServers struct {
}

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

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

type validateOpListLaunchActions struct {
}

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

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

type validateOpListTagsForResource struct {
}

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

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

type validateOpPutLaunchAction struct {
}

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

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

type validateOpRetryDataReplication struct {
}

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

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

type validateOpReverseReplication struct {
}

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

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

type validateOpStartFailbackLaunch struct {
}

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

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

type validateOpStartRecovery struct {
}

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

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

type validateOpStartReplication struct {
}

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

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

type validateOpStartSourceNetworkRecovery struct {
}

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

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

type validateOpStartSourceNetworkReplication struct {
}

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

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

type validateOpStopFailback struct {
}

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

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

type validateOpStopReplication struct {
}

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

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

type validateOpStopSourceNetworkReplication struct {
}

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

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

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

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

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

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

type validateOpUpdateLaunchConfiguration struct {
}

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

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

type validateOpUpdateLaunchConfigurationTemplate struct {
}

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

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

type validateOpUpdateReplicationConfiguration struct {
}

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

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

type validateOpUpdateReplicationConfigurationTemplate struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validatePITPolicyRule(v *types.PITPolicyRule) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PITPolicyRule"}
	if len(v.Units) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Units"))
	}
	if v.Interval == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Interval"))
	}
	if v.RetentionDuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RetentionDuration"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateOpAssociateSourceNetworkStackInput(v *AssociateSourceNetworkStackInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateSourceNetworkStackInput"}
	if v.SourceNetworkID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceNetworkID"))
	}
	if v.CfnStackName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CfnStackName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateReplicationConfigurationTemplateInput(v *CreateReplicationConfigurationTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReplicationConfigurationTemplateInput"}
	if v.StagingAreaSubnetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StagingAreaSubnetId"))
	}
	if v.AssociateDefaultSecurityGroup == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssociateDefaultSecurityGroup"))
	}
	if v.ReplicationServersSecurityGroupsIDs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationServersSecurityGroupsIDs"))
	}
	if v.ReplicationServerInstanceType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationServerInstanceType"))
	}
	if v.UseDedicatedReplicationServer == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UseDedicatedReplicationServer"))
	}
	if len(v.DefaultLargeStagingDiskType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DefaultLargeStagingDiskType"))
	}
	if len(v.EbsEncryption) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EbsEncryption"))
	}
	if len(v.DataPlaneRouting) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("DataPlaneRouting"))
	}
	if v.CreatePublicIP == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatePublicIP"))
	}
	if v.StagingAreaTags == nil {
		invalidParams.Add(smithy.NewErrParamRequired("StagingAreaTags"))
	}
	if v.PitPolicy == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PitPolicy"))
	} else if v.PitPolicy != nil {
		if err := validatePITPolicy(v.PitPolicy); err != nil {
			invalidParams.AddNested("PitPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSourceNetworkInput(v *CreateSourceNetworkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSourceNetworkInput"}
	if v.VpcID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("VpcID"))
	}
	if v.OriginAccountID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginAccountID"))
	}
	if v.OriginRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OriginRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteLaunchActionInput(v *DeleteLaunchActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteLaunchActionInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.ActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateOpPutLaunchActionInput(v *PutLaunchActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutLaunchActionInput"}
	if v.ResourceId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceId"))
	}
	if v.ActionCode == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionCode"))
	}
	if v.Order == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Order"))
	}
	if v.ActionId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionId"))
	}
	if v.Optional == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Optional"))
	}
	if v.Active == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Active"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ActionVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ActionVersion"))
	}
	if len(v.Category) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Category"))
	}
	if v.Description == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Description"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpStartRecoveryInput(v *StartRecoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartRecoveryInput"}
	if v.SourceServers == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceServers"))
	} else if v.SourceServers != nil {
		if err := validateStartRecoveryRequestSourceServers(v.SourceServers); err != nil {
			invalidParams.AddNested("SourceServers", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpStartSourceNetworkRecoveryInput(v *StartSourceNetworkRecoveryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartSourceNetworkRecoveryInput"}
	if v.SourceNetworks == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceNetworks"))
	} else if v.SourceNetworks != nil {
		if err := validateStartSourceNetworkRecoveryRequestNetworkEntries(v.SourceNetworks); err != nil {
			invalidParams.AddNested("SourceNetworks", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpStopSourceNetworkReplicationInput(v *StopSourceNetworkReplicationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StopSourceNetworkReplicationInput"}
	if v.SourceNetworkID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceNetworkID"))
	}
	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 validateOpTerminateRecoveryInstancesInput(v *TerminateRecoveryInstancesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TerminateRecoveryInstancesInput"}
	if v.RecoveryInstanceIDs == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryInstanceIDs"))
	}
	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.TagKeys == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TagKeys"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpUpdateReplicationConfigurationInput(v *UpdateReplicationConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReplicationConfigurationInput"}
	if v.SourceServerID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceServerID"))
	}
	if v.PitPolicy != nil {
		if err := validatePITPolicy(v.PitPolicy); err != nil {
			invalidParams.AddNested("PitPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateReplicationConfigurationTemplateInput(v *UpdateReplicationConfigurationTemplateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReplicationConfigurationTemplateInput"}
	if v.ReplicationConfigurationTemplateID == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReplicationConfigurationTemplateID"))
	}
	if v.PitPolicy != nil {
		if err := validatePITPolicy(v.PitPolicy); err != nil {
			invalidParams.AddNested("PitPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}