service/datazone/validators.go

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

package datazone

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

type validateOpAcceptPredictions struct {
}

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

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

type validateOpAcceptSubscriptionRequest struct {
}

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

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

type validateOpAddEntityOwner struct {
}

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

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

type validateOpAddPolicyGrant struct {
}

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

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

type validateOpAssociateEnvironmentRole struct {
}

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

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

type validateOpCancelMetadataGenerationRun struct {
}

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

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

type validateOpCancelSubscription struct {
}

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

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

type validateOpCreateAssetFilter struct {
}

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

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

type validateOpCreateAsset struct {
}

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

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

type validateOpCreateAssetRevision struct {
}

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

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

type validateOpCreateAssetType struct {
}

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

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

type validateOpCreateConnection struct {
}

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

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

type validateOpCreateDataProduct struct {
}

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

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

type validateOpCreateDataProductRevision struct {
}

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

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

type validateOpCreateDataSource struct {
}

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

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

type validateOpCreateDomain struct {
}

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

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

type validateOpCreateDomainUnit struct {
}

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

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

type validateOpCreateEnvironmentAction struct {
}

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

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

type validateOpCreateEnvironment struct {
}

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

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

type validateOpCreateEnvironmentProfile struct {
}

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

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

type validateOpCreateFormType struct {
}

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

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

type validateOpCreateGlossary struct {
}

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

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

type validateOpCreateGlossaryTerm struct {
}

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

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

type validateOpCreateGroupProfile struct {
}

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

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

type validateOpCreateListingChangeSet struct {
}

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

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

type validateOpCreateProject struct {
}

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

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

type validateOpCreateProjectMembership struct {
}

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

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

type validateOpCreateProjectProfile struct {
}

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

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

type validateOpCreateRule struct {
}

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

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

type validateOpCreateSubscriptionGrant struct {
}

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

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

type validateOpCreateSubscriptionRequest struct {
}

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

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

type validateOpCreateSubscriptionTarget struct {
}

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

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

type validateOpCreateUserProfile struct {
}

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

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

type validateOpDeleteAssetFilter struct {
}

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

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

type validateOpDeleteAsset struct {
}

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

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

type validateOpDeleteAssetType struct {
}

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

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

type validateOpDeleteConnection struct {
}

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

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

type validateOpDeleteDataProduct struct {
}

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

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

type validateOpDeleteDataSource struct {
}

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

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

type validateOpDeleteDomain struct {
}

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

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

type validateOpDeleteDomainUnit struct {
}

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

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

type validateOpDeleteEnvironmentAction struct {
}

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

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

type validateOpDeleteEnvironmentBlueprintConfiguration struct {
}

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

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

type validateOpDeleteEnvironment struct {
}

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

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

type validateOpDeleteEnvironmentProfile struct {
}

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

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

type validateOpDeleteFormType struct {
}

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

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

type validateOpDeleteGlossary struct {
}

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

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

type validateOpDeleteGlossaryTerm struct {
}

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

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

type validateOpDeleteListing struct {
}

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

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

type validateOpDeleteProject struct {
}

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

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

type validateOpDeleteProjectMembership struct {
}

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

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

type validateOpDeleteProjectProfile struct {
}

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

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

type validateOpDeleteRule struct {
}

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

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

type validateOpDeleteSubscriptionGrant struct {
}

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

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

type validateOpDeleteSubscriptionRequest struct {
}

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

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

type validateOpDeleteSubscriptionTarget struct {
}

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

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

type validateOpDeleteTimeSeriesDataPoints struct {
}

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

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

type validateOpDisassociateEnvironmentRole struct {
}

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

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

type validateOpGetAssetFilter struct {
}

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

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

type validateOpGetAsset struct {
}

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

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

type validateOpGetAssetType struct {
}

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

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

type validateOpGetConnection struct {
}

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

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

type validateOpGetDataProduct struct {
}

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

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

type validateOpGetDataSource struct {
}

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

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

type validateOpGetDataSourceRun struct {
}

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

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

type validateOpGetDomain struct {
}

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

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

type validateOpGetDomainUnit struct {
}

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

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

type validateOpGetEnvironmentAction struct {
}

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

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

type validateOpGetEnvironmentBlueprintConfiguration struct {
}

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

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

type validateOpGetEnvironmentBlueprint struct {
}

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

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

type validateOpGetEnvironmentCredentials struct {
}

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

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

type validateOpGetEnvironment struct {
}

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

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

type validateOpGetEnvironmentProfile struct {
}

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

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

type validateOpGetFormType struct {
}

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

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

type validateOpGetGlossary struct {
}

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

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

type validateOpGetGlossaryTerm struct {
}

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

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

type validateOpGetGroupProfile struct {
}

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

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

type validateOpGetIamPortalLoginUrl struct {
}

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

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

type validateOpGetJobRun struct {
}

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

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

type validateOpGetLineageEvent struct {
}

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

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

type validateOpGetLineageNode struct {
}

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

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

type validateOpGetListing struct {
}

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

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

type validateOpGetMetadataGenerationRun struct {
}

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

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

type validateOpGetProject struct {
}

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

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

type validateOpGetProjectProfile struct {
}

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

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

type validateOpGetRule struct {
}

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

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

type validateOpGetSubscriptionGrant struct {
}

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

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

type validateOpGetSubscription struct {
}

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

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

type validateOpGetSubscriptionRequestDetails struct {
}

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

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

type validateOpGetSubscriptionTarget struct {
}

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

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

type validateOpGetTimeSeriesDataPoint struct {
}

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

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

type validateOpGetUserProfile struct {
}

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

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

type validateOpListAssetFilters struct {
}

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

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

type validateOpListAssetRevisions struct {
}

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

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

type validateOpListConnections struct {
}

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

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

type validateOpListDataProductRevisions struct {
}

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

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

type validateOpListDataSourceRunActivities struct {
}

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

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

type validateOpListDataSourceRuns struct {
}

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

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

type validateOpListDataSources struct {
}

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

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

type validateOpListDomainUnitsForParent struct {
}

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

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

type validateOpListEntityOwners struct {
}

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

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

type validateOpListEnvironmentActions struct {
}

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

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

type validateOpListEnvironmentBlueprintConfigurations struct {
}

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

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

type validateOpListEnvironmentBlueprints struct {
}

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

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

type validateOpListEnvironmentProfiles struct {
}

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

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

type validateOpListEnvironments struct {
}

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

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

type validateOpListJobRuns struct {
}

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

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

type validateOpListLineageEvents struct {
}

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

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

type validateOpListLineageNodeHistory struct {
}

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

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

type validateOpListMetadataGenerationRuns struct {
}

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

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

type validateOpListNotifications struct {
}

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

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

type validateOpListPolicyGrants struct {
}

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

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

type validateOpListProjectMemberships struct {
}

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

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

type validateOpListProjectProfiles struct {
}

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

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

type validateOpListProjects struct {
}

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

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

type validateOpListRules struct {
}

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

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

type validateOpListSubscriptionGrants struct {
}

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

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

type validateOpListSubscriptionRequests struct {
}

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

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

type validateOpListSubscriptions struct {
}

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

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

type validateOpListSubscriptionTargets struct {
}

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

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

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

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

type validateOpPostLineageEvent struct {
}

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

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

type validateOpPostTimeSeriesDataPoints struct {
}

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

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

type validateOpPutEnvironmentBlueprintConfiguration struct {
}

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

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

type validateOpRejectPredictions struct {
}

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

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

type validateOpRejectSubscriptionRequest struct {
}

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

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

type validateOpRemoveEntityOwner struct {
}

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

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

type validateOpRemovePolicyGrant struct {
}

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

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

type validateOpRevokeSubscription struct {
}

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

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

type validateOpSearchGroupProfiles struct {
}

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

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

type validateOpSearch struct {
}

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

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

type validateOpSearchListings struct {
}

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

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

type validateOpSearchTypes struct {
}

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

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

type validateOpSearchUserProfiles struct {
}

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

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

type validateOpStartDataSourceRun struct {
}

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

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

type validateOpStartMetadataGenerationRun struct {
}

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

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

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

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

type validateOpUpdateConnection struct {
}

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

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

type validateOpUpdateDataSource struct {
}

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

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

type validateOpUpdateDomain struct {
}

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

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

type validateOpUpdateDomainUnit struct {
}

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

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

type validateOpUpdateEnvironmentAction struct {
}

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

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

type validateOpUpdateEnvironment struct {
}

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

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

type validateOpUpdateEnvironmentProfile struct {
}

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

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

type validateOpUpdateGlossary struct {
}

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

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

type validateOpUpdateGlossaryTerm struct {
}

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

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

type validateOpUpdateGroupProfile struct {
}

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

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

type validateOpUpdateProject struct {
}

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

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

type validateOpUpdateProjectProfile struct {
}

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

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

type validateOpUpdateRule struct {
}

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

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

type validateOpUpdateSubscriptionGrantStatus struct {
}

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

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

type validateOpUpdateSubscriptionRequest struct {
}

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

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

type validateOpUpdateSubscriptionTarget struct {
}

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

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

type validateOpUpdateUserProfile struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpStartMetadataGenerationRunValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpStartMetadataGenerationRun{}, 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 addOpUpdateAssetFilterValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateAssetFilter{}, middleware.After)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func validateAcceptedAssetScope(v *types.AcceptedAssetScope) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptedAssetScope"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.FilterIds == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FilterIds"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateAssetFilterConfiguration(v types.AssetFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetFilterConfiguration"}
	switch uv := v.(type) {
	case *types.AssetFilterConfigurationMemberRowConfiguration:
		if err := validateRowFilterConfiguration(&uv.Value); err != nil {
			invalidParams.AddNested("[rowConfiguration]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateAssetTargetNameMap(v *types.AssetTargetNameMap) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssetTargetNameMap"}
	if v.AssetId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetId"))
	}
	if v.TargetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateConnectionPropertiesInput(v types.ConnectionPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectionPropertiesInput"}
	switch uv := v.(type) {
	case *types.ConnectionPropertiesInputMemberHyperPodProperties:
		if err := validateHyperPodPropertiesInput(&uv.Value); err != nil {
			invalidParams.AddNested("[hyperPodProperties]", err.(smithy.InvalidParamsError))
		}

	case *types.ConnectionPropertiesInputMemberRedshiftProperties:
		if err := validateRedshiftPropertiesInput(&uv.Value); err != nil {
			invalidParams.AddNested("[redshiftProperties]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateConnectionPropertiesPatch(v types.ConnectionPropertiesPatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ConnectionPropertiesPatch"}
	switch uv := v.(type) {
	case *types.ConnectionPropertiesPatchMemberRedshiftProperties:
		if err := validateRedshiftPropertiesPatch(&uv.Value); err != nil {
			invalidParams.AddNested("[redshiftProperties]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateDataProductItem(v *types.DataProductItem) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataProductItem"}
	if len(v.ItemType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ItemType"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateDataSourceConfigurationInput(v types.DataSourceConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DataSourceConfigurationInput"}
	switch uv := v.(type) {
	case *types.DataSourceConfigurationInputMemberGlueRunConfiguration:
		if err := validateGlueRunConfigurationInput(&uv.Value); err != nil {
			invalidParams.AddNested("[glueRunConfiguration]", err.(smithy.InvalidParamsError))
		}

	case *types.DataSourceConfigurationInputMemberRedshiftRunConfiguration:
		if err := validateRedshiftRunConfigurationInput(&uv.Value); err != nil {
			invalidParams.AddNested("[redshiftRunConfiguration]", err.(smithy.InvalidParamsError))
		}

	case *types.DataSourceConfigurationInputMemberSageMakerRunConfiguration:
		if err := validateSageMakerRunConfigurationInput(&uv.Value); err != nil {
			invalidParams.AddNested("[sageMakerRunConfiguration]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateEnvironmentConfiguration(v *types.EnvironmentConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentConfiguration"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EnvironmentBlueprintId == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentBlueprintId"))
	}
	if v.AwsAccount == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsAccount"))
	}
	if v.AwsRegion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AwsRegion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEnvironmentDeploymentDetails(v *types.EnvironmentDeploymentDetails) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentDeploymentDetails"}
	if v.EnvironmentFailureReasons != nil {
		if err := validateEnvironmentFailureReasons(v.EnvironmentFailureReasons); err != nil {
			invalidParams.AddNested("EnvironmentFailureReasons", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateEnvironmentFailureReasons(v map[string][]types.EnvironmentError) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "EnvironmentFailureReasons"}
	for key := range v {
		if err := validateEnvironmentFailureReasonsList(v[key]); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateFilterClause(v types.FilterClause) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FilterClause"}
	switch uv := v.(type) {
	case *types.FilterClauseMemberAnd:
		if err := validateFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[and]", err.(smithy.InvalidParamsError))
		}

	case *types.FilterClauseMemberFilter:
		if err := validateFilter(&uv.Value); err != nil {
			invalidParams.AddNested("[filter]", err.(smithy.InvalidParamsError))
		}

	case *types.FilterClauseMemberOr:
		if err := validateFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[or]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateFormEntryInput(v *types.FormEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormEntryInput"}
	if v.TypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeIdentifier"))
	}
	if v.TypeRevision == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeRevision"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFormsInputMap(v map[string]types.FormEntryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FormsInputMap"}
	for key := range v {
		value := v[key]
		if err := validateFormEntryInput(&value); err != nil {
			invalidParams.AddNested(fmt.Sprintf("[%q]", key), err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGlueRunConfigurationInput(v *types.GlueRunConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GlueRunConfigurationInput"}
	if v.RelationalFilterConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalFilterConfigurations"))
	} else if v.RelationalFilterConfigurations != nil {
		if err := validateRelationalFilterConfigurations(v.RelationalFilterConfigurations); err != nil {
			invalidParams.AddNested("RelationalFilterConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateGrantedEntityInput(v types.GrantedEntityInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GrantedEntityInput"}
	switch uv := v.(type) {
	case *types.GrantedEntityInputMemberListing:
		if err := validateListingRevisionInput(&uv.Value); err != nil {
			invalidParams.AddNested("[listing]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateInExpression(v *types.InExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "InExpression"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateListingRevisionInput(v *types.ListingRevisionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListingRevisionInput"}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Revision == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Revision"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateMetadataFormEnforcementDetail(v *types.MetadataFormEnforcementDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetadataFormEnforcementDetail"}
	if v.RequiredMetadataForms != nil {
		if err := validateRequiredMetadataFormList(v.RequiredMetadataForms); err != nil {
			invalidParams.AddNested("RequiredMetadataForms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateMetadataFormReference(v *types.MetadataFormReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "MetadataFormReference"}
	if v.TypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeIdentifier"))
	}
	if v.TypeRevision == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeRevision"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateNotInExpression(v *types.NotInExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "NotInExpression"}
	if v.ColumnName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ColumnName"))
	}
	if v.Values == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Values"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOwnerProperties(v types.OwnerProperties) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "OwnerProperties"}
	switch uv := v.(type) {
	case *types.OwnerPropertiesMemberGroup:
		if err := validateOwnerGroupProperties(&uv.Value); err != nil {
			invalidParams.AddNested("[group]", err.(smithy.InvalidParamsError))
		}

	case *types.OwnerPropertiesMemberUser:
		if err := validateOwnerUserProperties(&uv.Value); err != nil {
			invalidParams.AddNested("[user]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validatePolicyGrantPrincipal(v types.PolicyGrantPrincipal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PolicyGrantPrincipal"}
	switch uv := v.(type) {
	case *types.PolicyGrantPrincipalMemberDomainUnit:
		if err := validateDomainUnitPolicyGrantPrincipal(&uv.Value); err != nil {
			invalidParams.AddNested("[domainUnit]", err.(smithy.InvalidParamsError))
		}

	case *types.PolicyGrantPrincipalMemberProject:
		if err := validateProjectPolicyGrantPrincipal(&uv.Value); err != nil {
			invalidParams.AddNested("[project]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProjectGrantFilter(v types.ProjectGrantFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProjectGrantFilter"}
	switch uv := v.(type) {
	case *types.ProjectGrantFilterMemberDomainUnitFilter:
		if err := validateDomainUnitFilterForProject(&uv.Value); err != nil {
			invalidParams.AddNested("[domainUnitFilter]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateProjectPolicyGrantPrincipal(v *types.ProjectPolicyGrantPrincipal) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ProjectPolicyGrantPrincipal"}
	if len(v.ProjectDesignation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectDesignation"))
	}
	if v.ProjectGrantFilter != nil {
		if err := validateProjectGrantFilter(v.ProjectGrantFilter); err != nil {
			invalidParams.AddNested("ProjectGrantFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateRedshiftCredentials(v types.RedshiftCredentials) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftCredentials"}
	switch uv := v.(type) {
	case *types.RedshiftCredentialsMemberUsernamePassword:
		if err := validateUsernamePassword(&uv.Value); err != nil {
			invalidParams.AddNested("[usernamePassword]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedshiftPropertiesInput(v *types.RedshiftPropertiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftPropertiesInput"}
	if v.Credentials != nil {
		if err := validateRedshiftCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedshiftPropertiesPatch(v *types.RedshiftPropertiesPatch) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftPropertiesPatch"}
	if v.Credentials != nil {
		if err := validateRedshiftCredentials(v.Credentials); err != nil {
			invalidParams.AddNested("Credentials", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRedshiftRunConfigurationInput(v *types.RedshiftRunConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftRunConfigurationInput"}
	if v.RelationalFilterConfigurations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RelationalFilterConfigurations"))
	} else if v.RelationalFilterConfigurations != nil {
		if err := validateRelationalFilterConfigurations(v.RelationalFilterConfigurations); err != nil {
			invalidParams.AddNested("RelationalFilterConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftCredentialConfiguration != nil {
		if err := validateRedshiftCredentialConfiguration(v.RedshiftCredentialConfiguration); err != nil {
			invalidParams.AddNested("RedshiftCredentialConfiguration", err.(smithy.InvalidParamsError))
		}
	}
	if v.RedshiftStorage != nil {
		if err := validateRedshiftStorage(v.RedshiftStorage); err != nil {
			invalidParams.AddNested("RedshiftStorage", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRedshiftStorage(v types.RedshiftStorage) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RedshiftStorage"}
	switch uv := v.(type) {
	case *types.RedshiftStorageMemberRedshiftClusterSource:
		if err := validateRedshiftClusterStorage(&uv.Value); err != nil {
			invalidParams.AddNested("[redshiftClusterSource]", err.(smithy.InvalidParamsError))
		}

	case *types.RedshiftStorageMemberRedshiftServerlessSource:
		if err := validateRedshiftServerlessStorage(&uv.Value); err != nil {
			invalidParams.AddNested("[redshiftServerlessSource]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRelationalFilterConfiguration(v *types.RelationalFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RelationalFilterConfiguration"}
	if v.DatabaseName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DatabaseName"))
	}
	if v.FilterExpressions != nil {
		if err := validateFilterExpressions(v.FilterExpressions); err != nil {
			invalidParams.AddNested("FilterExpressions", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateRowFilter(v types.RowFilter) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowFilter"}
	switch uv := v.(type) {
	case *types.RowFilterMemberAnd:
		if err := validateRowFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[and]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterMemberExpression:
		if err := validateRowFilterExpression(uv.Value); err != nil {
			invalidParams.AddNested("[expression]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterMemberOr:
		if err := validateRowFilterList(uv.Value); err != nil {
			invalidParams.AddNested("[or]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRowFilterConfiguration(v *types.RowFilterConfiguration) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowFilterConfiguration"}
	if v.RowFilter == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RowFilter"))
	} else if v.RowFilter != nil {
		if err := validateRowFilter(v.RowFilter); err != nil {
			invalidParams.AddNested("RowFilter", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRowFilterExpression(v types.RowFilterExpression) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RowFilterExpression"}
	switch uv := v.(type) {
	case *types.RowFilterExpressionMemberEqualTo:
		if err := validateEqualToExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[equalTo]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberGreaterThan:
		if err := validateGreaterThanExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[greaterThan]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberGreaterThanOrEqualTo:
		if err := validateGreaterThanOrEqualToExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[greaterThanOrEqualTo]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberIn:
		if err := validateInExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[in]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberIsNotNull:
		if err := validateIsNotNullExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[isNotNull]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberIsNull:
		if err := validateIsNullExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[isNull]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberLessThan:
		if err := validateLessThanExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[lessThan]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberLessThanOrEqualTo:
		if err := validateLessThanOrEqualToExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[lessThanOrEqualTo]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberLike:
		if err := validateLikeExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[like]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberNotEqualTo:
		if err := validateNotEqualToExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[notEqualTo]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberNotIn:
		if err := validateNotInExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[notIn]", err.(smithy.InvalidParamsError))
		}

	case *types.RowFilterExpressionMemberNotLike:
		if err := validateNotLikeExpression(&uv.Value); err != nil {
			invalidParams.AddNested("[notLike]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateRuleDetail(v types.RuleDetail) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleDetail"}
	switch uv := v.(type) {
	case *types.RuleDetailMemberMetadataFormEnforcementDetail:
		if err := validateMetadataFormEnforcementDetail(&uv.Value); err != nil {
			invalidParams.AddNested("[metadataFormEnforcementDetail]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleScope(v *types.RuleScope) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleScope"}
	if v.AssetType != nil {
		if err := validateAssetTypesForRule(v.AssetType); err != nil {
			invalidParams.AddNested("AssetType", err.(smithy.InvalidParamsError))
		}
	}
	if v.Project != nil {
		if err := validateProjectsForRule(v.Project); err != nil {
			invalidParams.AddNested("Project", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateRuleTarget(v types.RuleTarget) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RuleTarget"}
	switch uv := v.(type) {
	case *types.RuleTargetMemberDomainUnitTarget:
		if err := validateDomainUnitTarget(&uv.Value); err != nil {
			invalidParams.AddNested("[domainUnitTarget]", err.(smithy.InvalidParamsError))
		}

	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

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

func validateSubscriptionTargetForm(v *types.SubscriptionTargetForm) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SubscriptionTargetForm"}
	if v.FormName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormName"))
	}
	if v.Content == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Content"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTimeSeriesDataPointFormInput(v *types.TimeSeriesDataPointFormInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TimeSeriesDataPointFormInput"}
	if v.FormName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormName"))
	}
	if v.TypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeIdentifier"))
	}
	if v.Timestamp == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Timestamp"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateUsernamePassword(v *types.UsernamePassword) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UsernamePassword"}
	if v.Password == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Password"))
	}
	if v.Username == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Username"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptPredictionsInput(v *AcceptPredictionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptPredictionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.AcceptChoices != nil {
		if err := validateAcceptChoices(v.AcceptChoices); err != nil {
			invalidParams.AddNested("AcceptChoices", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAcceptSubscriptionRequestInput(v *AcceptSubscriptionRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AcceptSubscriptionRequestInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.AssetScopes != nil {
		if err := validateAcceptedAssetScopes(v.AssetScopes); err != nil {
			invalidParams.AddNested("AssetScopes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddEntityOwnerInput(v *AddEntityOwnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddEntityOwnerInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if v.Owner == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Owner"))
	} else if v.Owner != nil {
		if err := validateOwnerProperties(v.Owner); err != nil {
			invalidParams.AddNested("Owner", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddPolicyGrantInput(v *AddPolicyGrantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddPolicyGrantInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.PolicyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyType"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	} else if v.Principal != nil {
		if err := validatePolicyGrantPrincipal(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if v.Detail == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Detail"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAssociateEnvironmentRoleInput(v *AssociateEnvironmentRoleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AssociateEnvironmentRoleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.EnvironmentRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelMetadataGenerationRunInput(v *CancelMetadataGenerationRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelMetadataGenerationRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCancelSubscriptionInput(v *CancelSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CancelSubscriptionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetFilterInput(v *CreateAssetFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetFilterInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Configuration == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Configuration"))
	} else if v.Configuration != nil {
		if err := validateAssetFilterConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetInput(v *CreateAssetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.TypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypeIdentifier"))
	}
	if v.FormsInput != nil {
		if err := validateFormInputList(v.FormsInput); err != nil {
			invalidParams.AddNested("FormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetRevisionInput(v *CreateAssetRevisionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetRevisionInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.FormsInput != nil {
		if err := validateFormInputList(v.FormsInput); err != nil {
			invalidParams.AddNested("FormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateAssetTypeInput(v *CreateAssetTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateAssetTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.FormsInput == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormsInput"))
	} else if v.FormsInput != nil {
		if err := validateFormsInputMap(v.FormsInput); err != nil {
			invalidParams.AddNested("FormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateConnectionInput(v *CreateConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateConnectionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Props != nil {
		if err := validateConnectionPropertiesInput(v.Props); err != nil {
			invalidParams.AddNested("Props", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataProductInput(v *CreateDataProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataProductInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	if v.FormsInput != nil {
		if err := validateFormInputList(v.FormsInput); err != nil {
			invalidParams.AddNested("FormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.Items != nil {
		if err := validateDataProductItems(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataProductRevisionInput(v *CreateDataProductRevisionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataProductRevisionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Items != nil {
		if err := validateDataProductItems(v.Items); err != nil {
			invalidParams.AddNested("Items", err.(smithy.InvalidParamsError))
		}
	}
	if v.FormsInput != nil {
		if err := validateFormInputList(v.FormsInput); err != nil {
			invalidParams.AddNested("FormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateDataSourceInput(v *CreateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDataSourceInput"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Configuration != nil {
		if err := validateDataSourceConfigurationInput(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetFormsInput != nil {
		if err := validateFormInputList(v.AssetFormsInput); err != nil {
			invalidParams.AddNested("AssetFormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateDomainUnitInput(v *CreateDomainUnitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateDomainUnitInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.ParentDomainUnitIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentDomainUnitIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEnvironmentActionInput(v *CreateEnvironmentActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEnvironmentActionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Parameters == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Parameters"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEnvironmentInput(v *CreateEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEnvironmentInput"}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EnvironmentProfileIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentProfileIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateEnvironmentProfileInput(v *CreateEnvironmentProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateEnvironmentProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EnvironmentBlueprintIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentBlueprintIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateFormTypeInput(v *CreateFormTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFormTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Model == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Model"))
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGlossaryInput(v *CreateGlossaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGlossaryInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGlossaryTermInput(v *CreateGlossaryTermInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGlossaryTermInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.GlossaryIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GlossaryIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateGroupProfileInput(v *CreateGroupProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateGroupProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.GroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateListingChangeSetInput(v *CreateListingChangeSetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateListingChangeSetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateProjectMembershipInput(v *CreateProjectMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectMembershipInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if v.Member == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Member"))
	}
	if len(v.Designation) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Designation"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateProjectProfileInput(v *CreateProjectProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateProjectProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.EnvironmentConfigurations != nil {
		if err := validateEnvironmentConfigurationsList(v.EnvironmentConfigurations); err != nil {
			invalidParams.AddNested("EnvironmentConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateRuleInput(v *CreateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateRuleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	} else if v.Target != nil {
		if err := validateRuleTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if v.Scope == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Scope"))
	} else if v.Scope != nil {
		if err := validateRuleScope(v.Scope); err != nil {
			invalidParams.AddNested("Scope", err.(smithy.InvalidParamsError))
		}
	}
	if v.Detail == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Detail"))
	} else if v.Detail != nil {
		if err := validateRuleDetail(v.Detail); err != nil {
			invalidParams.AddNested("Detail", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubscriptionGrantInput(v *CreateSubscriptionGrantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionGrantInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.GrantedEntity == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GrantedEntity"))
	} else if v.GrantedEntity != nil {
		if err := validateGrantedEntityInput(v.GrantedEntity); err != nil {
			invalidParams.AddNested("GrantedEntity", err.(smithy.InvalidParamsError))
		}
	}
	if v.AssetTargetNames != nil {
		if err := validateAssetTargetNames(v.AssetTargetNames); err != nil {
			invalidParams.AddNested("AssetTargetNames", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubscriptionRequestInput(v *CreateSubscriptionRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionRequestInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.SubscribedPrincipals == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscribedPrincipals"))
	}
	if v.SubscribedListings == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscribedListings"))
	} else if v.SubscribedListings != nil {
		if err := validateSubscribedListingInputs(v.SubscribedListings); err != nil {
			invalidParams.AddNested("SubscribedListings", err.(smithy.InvalidParamsError))
		}
	}
	if v.RequestReason == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestReason"))
	}
	if v.MetadataForms != nil {
		if err := validateMetadataFormInputs(v.MetadataForms); err != nil {
			invalidParams.AddNested("MetadataForms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateSubscriptionTargetInput(v *CreateSubscriptionTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateSubscriptionTargetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Type == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.SubscriptionTargetConfig == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SubscriptionTargetConfig"))
	} else if v.SubscriptionTargetConfig != nil {
		if err := validateSubscriptionTargetForms(v.SubscriptionTargetConfig); err != nil {
			invalidParams.AddNested("SubscriptionTargetConfig", err.(smithy.InvalidParamsError))
		}
	}
	if v.AuthorizedPrincipals == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AuthorizedPrincipals"))
	}
	if v.ManageAccessRole == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ManageAccessRole"))
	}
	if v.ApplicableAssetTypes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ApplicableAssetTypes"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateUserProfileInput(v *CreateUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateUserProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.UserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAssetFilterInput(v *DeleteAssetFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssetFilterInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAssetInput(v *DeleteAssetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteAssetTypeInput(v *DeleteAssetTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteAssetTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteConnectionInput(v *DeleteConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteConnectionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDataProductInput(v *DeleteDataProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataProductInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteDataSourceInput(v *DeleteDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDataSourceInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpDeleteDomainUnitInput(v *DeleteDomainUnitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteDomainUnitInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEnvironmentActionInput(v *DeleteEnvironmentActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEnvironmentActionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEnvironmentBlueprintConfigurationInput(v *DeleteEnvironmentBlueprintConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEnvironmentBlueprintConfigurationInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentBlueprintIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentBlueprintIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEnvironmentInput(v *DeleteEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEnvironmentInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteEnvironmentProfileInput(v *DeleteEnvironmentProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteEnvironmentProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteFormTypeInput(v *DeleteFormTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteFormTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.FormTypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormTypeIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGlossaryInput(v *DeleteGlossaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlossaryInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteGlossaryTermInput(v *DeleteGlossaryTermInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteGlossaryTermInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteListingInput(v *DeleteListingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteListingInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteProjectInput(v *DeleteProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteProjectMembershipInput(v *DeleteProjectMembershipInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectMembershipInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if v.Member == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Member"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteProjectProfileInput(v *DeleteProjectProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteProjectProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteRuleInput(v *DeleteRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteRuleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSubscriptionGrantInput(v *DeleteSubscriptionGrantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubscriptionGrantInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSubscriptionRequestInput(v *DeleteSubscriptionRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubscriptionRequestInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteSubscriptionTargetInput(v *DeleteSubscriptionTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteSubscriptionTargetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDeleteTimeSeriesDataPointsInput(v *DeleteTimeSeriesDataPointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteTimeSeriesDataPointsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.FormName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDisassociateEnvironmentRoleInput(v *DisassociateEnvironmentRoleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DisassociateEnvironmentRoleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.EnvironmentRoleArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentRoleArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssetFilterInput(v *GetAssetFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssetFilterInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssetInput(v *GetAssetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetAssetTypeInput(v *GetAssetTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetAssetTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetConnectionInput(v *GetConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetConnectionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDataProductInput(v *GetDataProductInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataProductInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDataSourceInput(v *GetDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataSourceInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetDataSourceRunInput(v *GetDataSourceRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDataSourceRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetDomainUnitInput(v *GetDomainUnitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetDomainUnitInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentActionInput(v *GetEnvironmentActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentActionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentBlueprintConfigurationInput(v *GetEnvironmentBlueprintConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentBlueprintConfigurationInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentBlueprintIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentBlueprintIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentBlueprintInput(v *GetEnvironmentBlueprintInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentBlueprintInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentCredentialsInput(v *GetEnvironmentCredentialsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentCredentialsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentInput(v *GetEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetEnvironmentProfileInput(v *GetEnvironmentProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetEnvironmentProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetFormTypeInput(v *GetFormTypeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetFormTypeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.FormTypeIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormTypeIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGlossaryInput(v *GetGlossaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGlossaryInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGlossaryTermInput(v *GetGlossaryTermInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGlossaryTermInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetGroupProfileInput(v *GetGroupProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetGroupProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.GroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpGetJobRunInput(v *GetJobRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetJobRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLineageEventInput(v *GetLineageEventInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLineageEventInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetLineageNodeInput(v *GetLineageNodeInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLineageNodeInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetListingInput(v *GetListingInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetListingInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetMetadataGenerationRunInput(v *GetMetadataGenerationRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetMetadataGenerationRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetProjectInput(v *GetProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProjectInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetProjectProfileInput(v *GetProjectProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetProjectProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetRuleInput(v *GetRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetRuleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSubscriptionGrantInput(v *GetSubscriptionGrantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionGrantInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSubscriptionInput(v *GetSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSubscriptionRequestDetailsInput(v *GetSubscriptionRequestDetailsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionRequestDetailsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetSubscriptionTargetInput(v *GetSubscriptionTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetSubscriptionTargetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetTimeSeriesDataPointInput(v *GetTimeSeriesDataPointInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetTimeSeriesDataPointInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.FormName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetUserProfileInput(v *GetUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetUserProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.UserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssetFiltersInput(v *ListAssetFiltersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssetFiltersInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListAssetRevisionsInput(v *ListAssetRevisionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAssetRevisionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListConnectionsInput(v *ListConnectionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListConnectionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataProductRevisionsInput(v *ListDataProductRevisionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataProductRevisionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataSourceRunActivitiesInput(v *ListDataSourceRunActivitiesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataSourceRunActivitiesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataSourceRunsInput(v *ListDataSourceRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataSourceRunsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.DataSourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDataSourcesInput(v *ListDataSourcesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDataSourcesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListDomainUnitsForParentInput(v *ListDomainUnitsForParentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListDomainUnitsForParentInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ParentDomainUnitIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentDomainUnitIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListEntityOwnersInput(v *ListEntityOwnersInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEntityOwnersInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListEnvironmentActionsInput(v *ListEnvironmentActionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEnvironmentActionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListEnvironmentsInput(v *ListEnvironmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListEnvironmentsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListJobRunsInput(v *ListJobRunsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListJobRunsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.JobIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("JobIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListLineageNodeHistoryInput(v *ListLineageNodeHistoryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListLineageNodeHistoryInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpListNotificationsInput(v *ListNotificationsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListNotificationsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPolicyGrantsInput(v *ListPolicyGrantsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPolicyGrantsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.PolicyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListProjectMembershipsInput(v *ListProjectMembershipsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListProjectMembershipsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.ProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ProjectIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListRulesInput(v *ListRulesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListRulesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.TargetType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("TargetType"))
	}
	if v.TargetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListSubscriptionTargetsInput(v *ListSubscriptionTargetsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListSubscriptionTargetsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	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 validateOpListTimeSeriesDataPointsInput(v *ListTimeSeriesDataPointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTimeSeriesDataPointsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.FormName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("FormName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPostLineageEventInput(v *PostLineageEventInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostLineageEventInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Event == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Event"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPostTimeSeriesDataPointsInput(v *PostTimeSeriesDataPointsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PostTimeSeriesDataPointsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.Forms == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Forms"))
	} else if v.Forms != nil {
		if err := validateTimeSeriesDataPointFormInputList(v.Forms); err != nil {
			invalidParams.AddNested("Forms", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutEnvironmentBlueprintConfigurationInput(v *PutEnvironmentBlueprintConfigurationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutEnvironmentBlueprintConfigurationInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentBlueprintIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentBlueprintIdentifier"))
	}
	if v.EnabledRegions == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnabledRegions"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectPredictionsInput(v *RejectPredictionsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectPredictionsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.RejectChoices != nil {
		if err := validateRejectChoices(v.RejectChoices); err != nil {
			invalidParams.AddNested("RejectChoices", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRejectSubscriptionRequestInput(v *RejectSubscriptionRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RejectSubscriptionRequestInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveEntityOwnerInput(v *RemoveEntityOwnerInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveEntityOwnerInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if v.Owner == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Owner"))
	} else if v.Owner != nil {
		if err := validateOwnerProperties(v.Owner); err != nil {
			invalidParams.AddNested("Owner", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemovePolicyGrantInput(v *RemovePolicyGrantInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemovePolicyGrantInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.EntityType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EntityType"))
	}
	if v.EntityIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EntityIdentifier"))
	}
	if len(v.PolicyType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyType"))
	}
	if v.Principal == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Principal"))
	} else if v.Principal != nil {
		if err := validatePolicyGrantPrincipal(v.Principal); err != nil {
			invalidParams.AddNested("Principal", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRevokeSubscriptionInput(v *RevokeSubscriptionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RevokeSubscriptionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchGroupProfilesInput(v *SearchGroupProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchGroupProfilesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.GroupType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("GroupType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchInput(v *SearchInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.SearchScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SearchScope"))
	}
	if v.SearchIn != nil {
		if err := validateSearchInList(v.SearchIn); err != nil {
			invalidParams.AddNested("SearchIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateFilterClause(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sort != nil {
		if err := validateSearchSort(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchListingsInput(v *SearchListingsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchListingsInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.SearchIn != nil {
		if err := validateSearchInList(v.SearchIn); err != nil {
			invalidParams.AddNested("SearchIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateFilterClause(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sort != nil {
		if err := validateSearchSort(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchTypesInput(v *SearchTypesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchTypesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.SearchScope) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("SearchScope"))
	}
	if v.SearchIn != nil {
		if err := validateSearchInList(v.SearchIn); err != nil {
			invalidParams.AddNested("SearchIn", err.(smithy.InvalidParamsError))
		}
	}
	if v.Filters != nil {
		if err := validateFilterClause(v.Filters); err != nil {
			invalidParams.AddNested("Filters", err.(smithy.InvalidParamsError))
		}
	}
	if v.Sort != nil {
		if err := validateSearchSort(v.Sort); err != nil {
			invalidParams.AddNested("Sort", err.(smithy.InvalidParamsError))
		}
	}
	if v.Managed == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Managed"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpSearchUserProfilesInput(v *SearchUserProfilesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "SearchUserProfilesInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.UserType) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("UserType"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartDataSourceRunInput(v *StartDataSourceRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartDataSourceRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.DataSourceIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DataSourceIdentifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpStartMetadataGenerationRunInput(v *StartMetadataGenerationRunInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "StartMetadataGenerationRunInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if len(v.Type) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Type"))
	}
	if v.Target == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Target"))
	} else if v.Target != nil {
		if err := validateMetadataGenerationRunTarget(v.Target); err != nil {
			invalidParams.AddNested("Target", err.(smithy.InvalidParamsError))
		}
	}
	if v.OwningProjectIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OwningProjectIdentifier"))
	}
	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 validateOpUpdateAssetFilterInput(v *UpdateAssetFilterInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateAssetFilterInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Configuration != nil {
		if err := validateAssetFilterConfiguration(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateConnectionInput(v *UpdateConnectionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateConnectionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Props != nil {
		if err := validateConnectionPropertiesPatch(v.Props); err != nil {
			invalidParams.AddNested("Props", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateDataSourceInput(v *UpdateDataSourceInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDataSourceInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.AssetFormsInput != nil {
		if err := validateFormInputList(v.AssetFormsInput); err != nil {
			invalidParams.AddNested("AssetFormsInput", err.(smithy.InvalidParamsError))
		}
	}
	if v.Configuration != nil {
		if err := validateDataSourceConfigurationInput(v.Configuration); err != nil {
			invalidParams.AddNested("Configuration", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateDomainUnitInput(v *UpdateDomainUnitInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateDomainUnitInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEnvironmentActionInput(v *UpdateEnvironmentActionInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEnvironmentActionInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEnvironmentInput(v *UpdateEnvironmentInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEnvironmentInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateEnvironmentProfileInput(v *UpdateEnvironmentProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateEnvironmentProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGlossaryInput(v *UpdateGlossaryInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlossaryInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGlossaryTermInput(v *UpdateGlossaryTermInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGlossaryTermInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateGroupProfileInput(v *UpdateGroupProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateGroupProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.GroupIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("GroupIdentifier"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProjectInput(v *UpdateProjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProjectInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.EnvironmentDeploymentDetails != nil {
		if err := validateEnvironmentDeploymentDetails(v.EnvironmentDeploymentDetails); err != nil {
			invalidParams.AddNested("EnvironmentDeploymentDetails", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateProjectProfileInput(v *UpdateProjectProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateProjectProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.EnvironmentConfigurations != nil {
		if err := validateEnvironmentConfigurationsList(v.EnvironmentConfigurations); err != nil {
			invalidParams.AddNested("EnvironmentConfigurations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateRuleInput(v *UpdateRuleInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateRuleInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.Scope != nil {
		if err := validateRuleScope(v.Scope); err != nil {
			invalidParams.AddNested("Scope", err.(smithy.InvalidParamsError))
		}
	}
	if v.Detail != nil {
		if err := validateRuleDetail(v.Detail); err != nil {
			invalidParams.AddNested("Detail", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSubscriptionGrantStatusInput(v *UpdateSubscriptionGrantStatusInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionGrantStatusInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.AssetIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AssetIdentifier"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSubscriptionRequestInput(v *UpdateSubscriptionRequestInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionRequestInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.RequestReason == nil {
		invalidParams.Add(smithy.NewErrParamRequired("RequestReason"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateSubscriptionTargetInput(v *UpdateSubscriptionTargetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateSubscriptionTargetInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.EnvironmentIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("EnvironmentIdentifier"))
	}
	if v.Identifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Identifier"))
	}
	if v.SubscriptionTargetConfig != nil {
		if err := validateSubscriptionTargetForms(v.SubscriptionTargetConfig); err != nil {
			invalidParams.AddNested("SubscriptionTargetConfig", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateUserProfileInput(v *UpdateUserProfileInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateUserProfileInput"}
	if v.DomainIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DomainIdentifier"))
	}
	if v.UserIdentifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("UserIdentifier"))
	}
	if len(v.Status) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Status"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}