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

package migrationhub

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

type validateOpAssociateCreatedArtifact struct {
}

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

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

type validateOpAssociateDiscoveredResource struct {
}

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

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

type validateOpCreateProgressUpdateStream struct {
}

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

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

type validateOpDeleteProgressUpdateStream struct {
}

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

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

type validateOpDescribeApplicationState struct {
}

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

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

type validateOpDescribeMigrationTask struct {
}

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

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

type validateOpDisassociateCreatedArtifact struct {
}

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

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

type validateOpDisassociateDiscoveredResource struct {
}

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

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

type validateOpImportMigrationTask struct {
}

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

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

type validateOpListCreatedArtifacts struct {
}

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

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

type validateOpListDiscoveredResources struct {
}

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

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

type validateOpNotifyApplicationState struct {
}

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

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

type validateOpNotifyMigrationTaskState struct {
}

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

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

type validateOpPutResourceAttributes struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateResourceAttribute(v *types.ResourceAttribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ResourceAttribute"}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpAssociateCreatedArtifactInput(v *AssociateCreatedArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateCreatedArtifactInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.CreatedArtifact == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatedArtifact"))
	} else if v.CreatedArtifact != nil {
		if err := validateCreatedArtifact(v.CreatedArtifact); err != nil {
			invalidParams.AddNested("CreatedArtifact", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateDiscoveredResourceInput(v *AssociateDiscoveredResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateDiscoveredResourceInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.DiscoveredResource == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DiscoveredResource"))
	} else if v.DiscoveredResource != nil {
		if err := validateDiscoveredResource(v.DiscoveredResource); err != nil {
			invalidParams.AddNested("DiscoveredResource", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpDescribeMigrationTaskInput(v *DescribeMigrationTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DescribeMigrationTaskInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateCreatedArtifactInput(v *DisassociateCreatedArtifactInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateCreatedArtifactInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.CreatedArtifactName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("CreatedArtifactName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateDiscoveredResourceInput(v *DisassociateDiscoveredResourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateDiscoveredResourceInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.ConfigurationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ConfigurationId"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpImportMigrationTaskInput(v *ImportMigrationTaskInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ImportMigrationTaskInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListCreatedArtifactsInput(v *ListCreatedArtifactsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListCreatedArtifactsInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDiscoveredResourcesInput(v *ListDiscoveredResourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDiscoveredResourcesInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpNotifyApplicationStateInput(v *NotifyApplicationStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyApplicationStateInput"}
	if v.ApplicationId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicationId"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpNotifyMigrationTaskStateInput(v *NotifyMigrationTaskStateInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotifyMigrationTaskStateInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.Task == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Task"))
	} else if v.Task != nil {
		if err := validateTask(v.Task); err != nil {
			invalidParams.AddNested("Task", err.(smithy.InvalidParamsError))
		}
	}
	if v.UpdateDateTime == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UpdateDateTime"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutResourceAttributesInput(v *PutResourceAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutResourceAttributesInput"}
	if v.ProgressUpdateStream == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProgressUpdateStream"))
	}
	if v.MigrationTaskName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MigrationTaskName"))
	}
	if v.ResourceAttributeList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ResourceAttributeList"))
	} else if v.ResourceAttributeList != nil {
		if err := validateResourceAttributeList(v.ResourceAttributeList); err != nil {
			invalidParams.AddNested("ResourceAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}