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

package route53recoveryreadiness

import (
	"context"
	"fmt"
	smithy "github.com/aws/smithy-go"
	"github.com/aws/smithy-go/middleware"
)

type validateOpCreateCell struct {
}

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

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

type validateOpCreateCrossAccountAuthorization struct {
}

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

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

type validateOpCreateReadinessCheck struct {
}

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

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

type validateOpCreateRecoveryGroup struct {
}

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

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

type validateOpCreateResourceSet struct {
}

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

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

type validateOpDeleteCell struct {
}

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

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

type validateOpDeleteCrossAccountAuthorization struct {
}

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

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

type validateOpDeleteReadinessCheck struct {
}

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

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

type validateOpDeleteRecoveryGroup struct {
}

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

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

type validateOpDeleteResourceSet struct {
}

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

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

type validateOpGetArchitectureRecommendations struct {
}

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

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

type validateOpGetCell struct {
}

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

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

type validateOpGetCellReadinessSummary struct {
}

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

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

type validateOpGetReadinessCheck struct {
}

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

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

type validateOpGetReadinessCheckResourceStatus struct {
}

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

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

type validateOpGetReadinessCheckStatus struct {
}

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

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

type validateOpGetRecoveryGroup struct {
}

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

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

type validateOpGetRecoveryGroupReadinessSummary struct {
}

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

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

type validateOpGetResourceSet struct {
}

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

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

type validateOpListTagsForResources struct {
}

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

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

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

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

type validateOpUpdateReadinessCheck struct {
}

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

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

type validateOpUpdateRecoveryGroup struct {
}

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

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

type validateOpUpdateResourceSet struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpListTagsForResourcesValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpListTagsForResources{}, 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 addOpUpdateCellValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateCell{}, middleware.After)
}

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

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

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

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

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

func validateOpCreateReadinessCheckInput(v *CreateReadinessCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateReadinessCheckInput"}
	if v.ReadinessCheckName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReadinessCheckName"))
	}
	if v.ResourceSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateResourceSetInput(v *CreateResourceSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateResourceSetInput"}
	if v.ResourceSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetName"))
	}
	if v.ResourceSetType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetType"))
	}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

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

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

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

func validateOpGetReadinessCheckResourceStatusInput(v *GetReadinessCheckResourceStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetReadinessCheckResourceStatusInput"}
	if v.ReadinessCheckName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReadinessCheckName"))
	}
	if v.ResourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpUpdateCellInput(v *UpdateCellInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateCellInput"}
	if v.CellName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CellName"))
	}
	if v.Cells == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cells"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateReadinessCheckInput(v *UpdateReadinessCheckInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateReadinessCheckInput"}
	if v.ReadinessCheckName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ReadinessCheckName"))
	}
	if v.ResourceSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRecoveryGroupInput(v *UpdateRecoveryGroupInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRecoveryGroupInput"}
	if v.Cells == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Cells"))
	}
	if v.RecoveryGroupName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RecoveryGroupName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateResourceSetInput(v *UpdateResourceSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateResourceSetInput"}
	if v.ResourceSetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetName"))
	}
	if v.ResourceSetType == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceSetType"))
	}
	if v.Resources == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Resources"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}