validators.go

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

package clouddirectory

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

type validateOpAddFacetToObject struct {
}

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

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

type validateOpApplySchema struct {
}

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

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

type validateOpAttachObject struct {
}

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

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

type validateOpAttachPolicy struct {
}

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

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

type validateOpAttachToIndex struct {
}

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

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

type validateOpAttachTypedLink struct {
}

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

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

type validateOpBatchRead struct {
}

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

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

type validateOpBatchWrite struct {
}

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

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

type validateOpCreateDirectory struct {
}

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

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

type validateOpCreateFacet struct {
}

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

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

type validateOpCreateIndex struct {
}

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

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

type validateOpCreateObject struct {
}

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

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

type validateOpCreateSchema struct {
}

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

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

type validateOpCreateTypedLinkFacet struct {
}

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

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

type validateOpDeleteDirectory struct {
}

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

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

type validateOpDeleteFacet struct {
}

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

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

type validateOpDeleteObject struct {
}

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

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

type validateOpDeleteSchema struct {
}

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

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

type validateOpDeleteTypedLinkFacet struct {
}

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

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

type validateOpDetachFromIndex struct {
}

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

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

type validateOpDetachObject struct {
}

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

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

type validateOpDetachPolicy struct {
}

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

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

type validateOpDetachTypedLink struct {
}

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

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

type validateOpDisableDirectory struct {
}

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

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

type validateOpEnableDirectory struct {
}

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

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

type validateOpGetAppliedSchemaVersion struct {
}

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

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

type validateOpGetDirectory struct {
}

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

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

type validateOpGetFacet struct {
}

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

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

type validateOpGetLinkAttributes struct {
}

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

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

type validateOpGetObjectAttributes struct {
}

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

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

type validateOpGetObjectInformation struct {
}

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

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

type validateOpGetSchemaAsJson struct {
}

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

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

type validateOpGetTypedLinkFacetInformation struct {
}

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

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

type validateOpListAppliedSchemaArns struct {
}

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

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

type validateOpListAttachedIndices struct {
}

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

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

type validateOpListFacetAttributes struct {
}

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

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

type validateOpListFacetNames struct {
}

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

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

type validateOpListIncomingTypedLinks struct {
}

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

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

type validateOpListIndex struct {
}

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

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

type validateOpListObjectAttributes struct {
}

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

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

type validateOpListObjectChildren struct {
}

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

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

type validateOpListObjectParentPaths struct {
}

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

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

type validateOpListObjectParents struct {
}

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

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

type validateOpListObjectPolicies struct {
}

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

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

type validateOpListOutgoingTypedLinks struct {
}

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

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

type validateOpListPolicyAttachments struct {
}

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

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

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

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

type validateOpListTypedLinkFacetNames struct {
}

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

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

type validateOpLookupPolicy struct {
}

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

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

type validateOpPublishSchema struct {
}

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

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

type validateOpPutSchemaFromJson struct {
}

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

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

type validateOpRemoveFacetFromObject struct {
}

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

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

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

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

type validateOpUpdateLinkAttributes struct {
}

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

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

type validateOpUpdateObjectAttributes struct {
}

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

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

type validateOpUpdateSchema struct {
}

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

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

type validateOpUpdateTypedLinkFacet struct {
}

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

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

type validateOpUpgradeAppliedSchema struct {
}

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

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

type validateOpUpgradePublishedSchema struct {
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func addOpRemoveFacetFromObjectValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpRemoveFacetFromObject{}, 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 addOpUpdateFacetValidationMiddleware(stack *middleware.Stack) error {
	return stack.Initialize.Add(&validateOpUpdateFacet{}, middleware.After)
}

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

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

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

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

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

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

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

func validateAttributeKeyAndValue(v *types.AttributeKeyAndValue) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttributeKeyAndValue"}
	if v.Key == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Key"))
	} else if v.Key != nil {
		if err := validateAttributeKey(v.Key); err != nil {
			invalidParams.AddNested("Key", err.(smithy.InvalidParamsError))
		}
	}
	if v.Value == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Value"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

func validateBatchAddFacetToObject(v *types.BatchAddFacetToObject) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAddFacetToObject"}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.ObjectAttributeList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectAttributeList"))
	} else if v.ObjectAttributeList != nil {
		if err := validateAttributeKeyAndValueList(v.ObjectAttributeList); err != nil {
			invalidParams.AddNested("ObjectAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchAttachObject(v *types.BatchAttachObject) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAttachObject"}
	if v.ParentReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentReference"))
	}
	if v.ChildReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChildReference"))
	}
	if v.LinkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LinkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchAttachPolicy(v *types.BatchAttachPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAttachPolicy"}
	if v.PolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReference"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchAttachToIndex(v *types.BatchAttachToIndex) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAttachToIndex"}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if v.TargetReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchAttachTypedLink(v *types.BatchAttachTypedLink) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchAttachTypedLink"}
	if v.SourceObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceObjectReference"))
	}
	if v.TargetObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetObjectReference"))
	}
	if v.TypedLinkFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkFacet"))
	} else if v.TypedLinkFacet != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.TypedLinkFacet); err != nil {
			invalidParams.AddNested("TypedLinkFacet", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateAttributeNameAndValueList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchCreateIndex(v *types.BatchCreateIndex) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateIndex"}
	if v.OrderedIndexedAttributeList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrderedIndexedAttributeList"))
	} else if v.OrderedIndexedAttributeList != nil {
		if err := validateAttributeKeyList(v.OrderedIndexedAttributeList); err != nil {
			invalidParams.AddNested("OrderedIndexedAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchCreateObject(v *types.BatchCreateObject) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchCreateObject"}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.ObjectAttributeList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectAttributeList"))
	} else if v.ObjectAttributeList != nil {
		if err := validateAttributeKeyAndValueList(v.ObjectAttributeList); err != nil {
			invalidParams.AddNested("ObjectAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchDetachFromIndex(v *types.BatchDetachFromIndex) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDetachFromIndex"}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if v.TargetReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchDetachObject(v *types.BatchDetachObject) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDetachObject"}
	if v.ParentReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentReference"))
	}
	if v.LinkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LinkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchDetachPolicy(v *types.BatchDetachPolicy) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDetachPolicy"}
	if v.PolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReference"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchDetachTypedLink(v *types.BatchDetachTypedLink) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchDetachTypedLink"}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchGetLinkAttributes(v *types.BatchGetLinkAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetLinkAttributes"}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchGetObjectAttributes(v *types.BatchGetObjectAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchGetObjectAttributes"}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.AttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBatchListIncomingTypedLinks(v *types.BatchListIncomingTypedLinks) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchListIncomingTypedLinks"}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.FilterAttributeRanges != nil {
		if err := validateTypedLinkAttributeRangeList(v.FilterAttributeRanges); err != nil {
			invalidParams.AddNested("FilterAttributeRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterTypedLink != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.FilterTypedLink); err != nil {
			invalidParams.AddNested("FilterTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchListIndex(v *types.BatchListIndex) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchListIndex"}
	if v.RangesOnIndexedValues != nil {
		if err := validateObjectAttributeRangeList(v.RangesOnIndexedValues); err != nil {
			invalidParams.AddNested("RangesOnIndexedValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateBatchListOutgoingTypedLinks(v *types.BatchListOutgoingTypedLinks) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchListOutgoingTypedLinks"}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.FilterAttributeRanges != nil {
		if err := validateTypedLinkAttributeRangeList(v.FilterAttributeRanges); err != nil {
			invalidParams.AddNested("FilterAttributeRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterTypedLink != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.FilterTypedLink); err != nil {
			invalidParams.AddNested("FilterTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateBatchReadOperation(v *types.BatchReadOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchReadOperation"}
	if v.ListObjectAttributes != nil {
		if err := validateBatchListObjectAttributes(v.ListObjectAttributes); err != nil {
			invalidParams.AddNested("ListObjectAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListObjectChildren != nil {
		if err := validateBatchListObjectChildren(v.ListObjectChildren); err != nil {
			invalidParams.AddNested("ListObjectChildren", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListAttachedIndices != nil {
		if err := validateBatchListAttachedIndices(v.ListAttachedIndices); err != nil {
			invalidParams.AddNested("ListAttachedIndices", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListObjectParentPaths != nil {
		if err := validateBatchListObjectParentPaths(v.ListObjectParentPaths); err != nil {
			invalidParams.AddNested("ListObjectParentPaths", err.(smithy.InvalidParamsError))
		}
	}
	if v.GetObjectInformation != nil {
		if err := validateBatchGetObjectInformation(v.GetObjectInformation); err != nil {
			invalidParams.AddNested("GetObjectInformation", err.(smithy.InvalidParamsError))
		}
	}
	if v.GetObjectAttributes != nil {
		if err := validateBatchGetObjectAttributes(v.GetObjectAttributes); err != nil {
			invalidParams.AddNested("GetObjectAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListObjectParents != nil {
		if err := validateBatchListObjectParents(v.ListObjectParents); err != nil {
			invalidParams.AddNested("ListObjectParents", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListObjectPolicies != nil {
		if err := validateBatchListObjectPolicies(v.ListObjectPolicies); err != nil {
			invalidParams.AddNested("ListObjectPolicies", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListPolicyAttachments != nil {
		if err := validateBatchListPolicyAttachments(v.ListPolicyAttachments); err != nil {
			invalidParams.AddNested("ListPolicyAttachments", err.(smithy.InvalidParamsError))
		}
	}
	if v.LookupPolicy != nil {
		if err := validateBatchLookupPolicy(v.LookupPolicy); err != nil {
			invalidParams.AddNested("LookupPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListIndex != nil {
		if err := validateBatchListIndex(v.ListIndex); err != nil {
			invalidParams.AddNested("ListIndex", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListOutgoingTypedLinks != nil {
		if err := validateBatchListOutgoingTypedLinks(v.ListOutgoingTypedLinks); err != nil {
			invalidParams.AddNested("ListOutgoingTypedLinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.ListIncomingTypedLinks != nil {
		if err := validateBatchListIncomingTypedLinks(v.ListIncomingTypedLinks); err != nil {
			invalidParams.AddNested("ListIncomingTypedLinks", err.(smithy.InvalidParamsError))
		}
	}
	if v.GetLinkAttributes != nil {
		if err := validateBatchGetLinkAttributes(v.GetLinkAttributes); err != nil {
			invalidParams.AddNested("GetLinkAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateBatchRemoveFacetFromObject(v *types.BatchRemoveFacetFromObject) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchRemoveFacetFromObject"}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchUpdateLinkAttributes(v *types.BatchUpdateLinkAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateLinkAttributes"}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeUpdates"))
	} else if v.AttributeUpdates != nil {
		if err := validateLinkAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchUpdateObjectAttributes(v *types.BatchUpdateObjectAttributes) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchUpdateObjectAttributes"}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.AttributeUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeUpdates"))
	} else if v.AttributeUpdates != nil {
		if err := validateObjectAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateBatchWriteOperation(v *types.BatchWriteOperation) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchWriteOperation"}
	if v.CreateObject != nil {
		if err := validateBatchCreateObject(v.CreateObject); err != nil {
			invalidParams.AddNested("CreateObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachObject != nil {
		if err := validateBatchAttachObject(v.AttachObject); err != nil {
			invalidParams.AddNested("AttachObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.DetachObject != nil {
		if err := validateBatchDetachObject(v.DetachObject); err != nil {
			invalidParams.AddNested("DetachObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.UpdateObjectAttributes != nil {
		if err := validateBatchUpdateObjectAttributes(v.UpdateObjectAttributes); err != nil {
			invalidParams.AddNested("UpdateObjectAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.DeleteObject != nil {
		if err := validateBatchDeleteObject(v.DeleteObject); err != nil {
			invalidParams.AddNested("DeleteObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.AddFacetToObject != nil {
		if err := validateBatchAddFacetToObject(v.AddFacetToObject); err != nil {
			invalidParams.AddNested("AddFacetToObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.RemoveFacetFromObject != nil {
		if err := validateBatchRemoveFacetFromObject(v.RemoveFacetFromObject); err != nil {
			invalidParams.AddNested("RemoveFacetFromObject", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachPolicy != nil {
		if err := validateBatchAttachPolicy(v.AttachPolicy); err != nil {
			invalidParams.AddNested("AttachPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.DetachPolicy != nil {
		if err := validateBatchDetachPolicy(v.DetachPolicy); err != nil {
			invalidParams.AddNested("DetachPolicy", err.(smithy.InvalidParamsError))
		}
	}
	if v.CreateIndex != nil {
		if err := validateBatchCreateIndex(v.CreateIndex); err != nil {
			invalidParams.AddNested("CreateIndex", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachToIndex != nil {
		if err := validateBatchAttachToIndex(v.AttachToIndex); err != nil {
			invalidParams.AddNested("AttachToIndex", err.(smithy.InvalidParamsError))
		}
	}
	if v.DetachFromIndex != nil {
		if err := validateBatchDetachFromIndex(v.DetachFromIndex); err != nil {
			invalidParams.AddNested("DetachFromIndex", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttachTypedLink != nil {
		if err := validateBatchAttachTypedLink(v.AttachTypedLink); err != nil {
			invalidParams.AddNested("AttachTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if v.DetachTypedLink != nil {
		if err := validateBatchDetachTypedLink(v.DetachTypedLink); err != nil {
			invalidParams.AddNested("DetachTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if v.UpdateLinkAttributes != nil {
		if err := validateBatchUpdateLinkAttributes(v.UpdateLinkAttributes); err != nil {
			invalidParams.AddNested("UpdateLinkAttributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateFacetAttribute(v *types.FacetAttribute) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FacetAttribute"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AttributeDefinition != nil {
		if err := validateFacetAttributeDefinition(v.AttributeDefinition); err != nil {
			invalidParams.AddNested("AttributeDefinition", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeReference != nil {
		if err := validateFacetAttributeReference(v.AttributeReference); err != nil {
			invalidParams.AddNested("AttributeReference", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateFacetAttributeReference(v *types.FacetAttributeReference) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FacetAttributeReference"}
	if v.TargetFacetName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetFacetName"))
	}
	if v.TargetAttributeName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetAttributeName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateFacetAttributeUpdate(v *types.FacetAttributeUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "FacetAttributeUpdate"}
	if v.Attribute != nil {
		if err := validateFacetAttribute(v.Attribute); err != nil {
			invalidParams.AddNested("Attribute", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateLinkAttributeUpdate(v *types.LinkAttributeUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LinkAttributeUpdate"}
	if v.AttributeKey != nil {
		if err := validateAttributeKey(v.AttributeKey); err != nil {
			invalidParams.AddNested("AttributeKey", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateObjectAttributeRange(v *types.ObjectAttributeRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ObjectAttributeRange"}
	if v.AttributeKey != nil {
		if err := validateAttributeKey(v.AttributeKey); err != nil {
			invalidParams.AddNested("AttributeKey", err.(smithy.InvalidParamsError))
		}
	}
	if v.Range != nil {
		if err := validateTypedAttributeValueRange(v.Range); err != nil {
			invalidParams.AddNested("Range", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateObjectAttributeUpdate(v *types.ObjectAttributeUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ObjectAttributeUpdate"}
	if v.ObjectAttributeKey != nil {
		if err := validateAttributeKey(v.ObjectAttributeKey); err != nil {
			invalidParams.AddNested("ObjectAttributeKey", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTypedAttributeValueRange(v *types.TypedAttributeValueRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedAttributeValueRange"}
	if len(v.StartMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("StartMode"))
	}
	if len(v.EndMode) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("EndMode"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateTypedLinkAttributeRange(v *types.TypedLinkAttributeRange) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedLinkAttributeRange"}
	if v.Range == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Range"))
	} else if v.Range != nil {
		if err := validateTypedAttributeValueRange(v.Range); err != nil {
			invalidParams.AddNested("Range", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTypedLinkFacet(v *types.TypedLinkFacet) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedLinkFacet"}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateTypedLinkAttributeDefinitionList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdentityAttributeOrder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityAttributeOrder"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTypedLinkFacetAttributeUpdate(v *types.TypedLinkFacetAttributeUpdate) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedLinkFacetAttributeUpdate"}
	if v.Attribute == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attribute"))
	} else if v.Attribute != nil {
		if err := validateTypedLinkAttributeDefinition(v.Attribute); err != nil {
			invalidParams.AddNested("Attribute", err.(smithy.InvalidParamsError))
		}
	}
	if len(v.Action) == 0 {
		invalidParams.Add(smithy.NewErrParamRequired("Action"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateTypedLinkSchemaAndFacetName(v *types.TypedLinkSchemaAndFacetName) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedLinkSchemaAndFacetName"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.TypedLinkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateTypedLinkSpecifier(v *types.TypedLinkSpecifier) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "TypedLinkSpecifier"}
	if v.TypedLinkFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkFacet"))
	} else if v.TypedLinkFacet != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.TypedLinkFacet); err != nil {
			invalidParams.AddNested("TypedLinkFacet", err.(smithy.InvalidParamsError))
		}
	}
	if v.SourceObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceObjectReference"))
	}
	if v.TargetObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetObjectReference"))
	}
	if v.IdentityAttributeValues == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityAttributeValues"))
	} else if v.IdentityAttributeValues != nil {
		if err := validateAttributeNameAndValueList(v.IdentityAttributeValues); err != nil {
			invalidParams.AddNested("IdentityAttributeValues", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAddFacetToObjectInput(v *AddFacetToObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AddFacetToObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.ObjectAttributeList != nil {
		if err := validateAttributeKeyAndValueList(v.ObjectAttributeList); err != nil {
			invalidParams.AddNested("ObjectAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpApplySchemaInput(v *ApplySchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ApplySchemaInput"}
	if v.PublishedSchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublishedSchemaArn"))
	}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachObjectInput(v *AttachObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ParentReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentReference"))
	}
	if v.ChildReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ChildReference"))
	}
	if v.LinkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LinkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachPolicyInput(v *AttachPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachPolicyInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.PolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReference"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachToIndexInput(v *AttachToIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachToIndexInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if v.TargetReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpAttachTypedLinkInput(v *AttachTypedLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "AttachTypedLinkInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.SourceObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SourceObjectReference"))
	}
	if v.TargetObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetObjectReference"))
	}
	if v.TypedLinkFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkFacet"))
	} else if v.TypedLinkFacet != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.TypedLinkFacet); err != nil {
			invalidParams.AddNested("TypedLinkFacet", err.(smithy.InvalidParamsError))
		}
	}
	if v.Attributes == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Attributes"))
	} else if v.Attributes != nil {
		if err := validateAttributeNameAndValueList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchReadInput(v *BatchReadInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchReadInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.Operations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Operations"))
	} else if v.Operations != nil {
		if err := validateBatchReadOperationList(v.Operations); err != nil {
			invalidParams.AddNested("Operations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpBatchWriteInput(v *BatchWriteInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "BatchWriteInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.Operations == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Operations"))
	} else if v.Operations != nil {
		if err := validateBatchWriteOperationList(v.Operations); err != nil {
			invalidParams.AddNested("Operations", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateFacetInput(v *CreateFacetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateFacetInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.Attributes != nil {
		if err := validateFacetAttributeList(v.Attributes); err != nil {
			invalidParams.AddNested("Attributes", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateIndexInput(v *CreateIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateIndexInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.OrderedIndexedAttributeList == nil {
		invalidParams.Add(smithy.NewErrParamRequired("OrderedIndexedAttributeList"))
	} else if v.OrderedIndexedAttributeList != nil {
		if err := validateAttributeKeyList(v.OrderedIndexedAttributeList); err != nil {
			invalidParams.AddNested("OrderedIndexedAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpCreateObjectInput(v *CreateObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.SchemaFacets == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacets"))
	}
	if v.ObjectAttributeList != nil {
		if err := validateAttributeKeyAndValueList(v.ObjectAttributeList); err != nil {
			invalidParams.AddNested("ObjectAttributeList", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpCreateTypedLinkFacetInput(v *CreateTypedLinkFacetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "CreateTypedLinkFacetInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Facet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Facet"))
	} else if v.Facet != nil {
		if err := validateTypedLinkFacet(v.Facet); err != nil {
			invalidParams.AddNested("Facet", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDeleteObjectInput(v *DeleteObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DeleteObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpDetachFromIndexInput(v *DetachFromIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachFromIndexInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if v.TargetReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachObjectInput(v *DetachObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ParentReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ParentReference"))
	}
	if v.LinkName == nil {
		invalidParams.Add(smithy.NewErrParamRequired("LinkName"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachPolicyInput(v *DetachPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachPolicyInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.PolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReference"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpDetachTypedLinkInput(v *DetachTypedLinkInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "DetachTypedLinkInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

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

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

func validateOpGetLinkAttributesInput(v *GetLinkAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetLinkAttributesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetObjectAttributesInput(v *GetObjectAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetObjectAttributesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.AttributeNames == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeNames"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpGetObjectInformationInput(v *GetObjectInformationInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "GetObjectInformationInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

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

func validateOpListAttachedIndicesInput(v *ListAttachedIndicesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListAttachedIndicesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.TargetReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TargetReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

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

func validateOpListIncomingTypedLinksInput(v *ListIncomingTypedLinksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIncomingTypedLinksInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.FilterAttributeRanges != nil {
		if err := validateTypedLinkAttributeRangeList(v.FilterAttributeRanges); err != nil {
			invalidParams.AddNested("FilterAttributeRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterTypedLink != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.FilterTypedLink); err != nil {
			invalidParams.AddNested("FilterTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListIndexInput(v *ListIndexInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListIndexInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.RangesOnIndexedValues != nil {
		if err := validateObjectAttributeRangeList(v.RangesOnIndexedValues); err != nil {
			invalidParams.AddNested("RangesOnIndexedValues", err.(smithy.InvalidParamsError))
		}
	}
	if v.IndexReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IndexReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListObjectAttributesInput(v *ListObjectAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListObjectAttributesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListObjectChildrenInput(v *ListObjectChildrenInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListObjectChildrenInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListObjectParentPathsInput(v *ListObjectParentPathsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListObjectParentPathsInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListObjectParentsInput(v *ListObjectParentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListObjectParentsInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListObjectPoliciesInput(v *ListObjectPoliciesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListObjectPoliciesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListOutgoingTypedLinksInput(v *ListOutgoingTypedLinksInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListOutgoingTypedLinksInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.FilterAttributeRanges != nil {
		if err := validateTypedLinkAttributeRangeList(v.FilterAttributeRanges); err != nil {
			invalidParams.AddNested("FilterAttributeRanges", err.(smithy.InvalidParamsError))
		}
	}
	if v.FilterTypedLink != nil {
		if err := validateTypedLinkSchemaAndFacetName(v.FilterTypedLink); err != nil {
			invalidParams.AddNested("FilterTypedLink", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpListPolicyAttachmentsInput(v *ListPolicyAttachmentsInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListPolicyAttachmentsInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.PolicyReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PolicyReference"))
	}
	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 validateOpListTypedLinkFacetAttributesInput(v *ListTypedLinkFacetAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "ListTypedLinkFacetAttributesInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpLookupPolicyInput(v *LookupPolicyInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "LookupPolicyInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPublishSchemaInput(v *PublishSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PublishSchemaInput"}
	if v.DevelopmentSchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DevelopmentSchemaArn"))
	}
	if v.Version == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Version"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpPutSchemaFromJsonInput(v *PutSchemaFromJsonInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "PutSchemaFromJsonInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Document == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Document"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpRemoveFacetFromObjectInput(v *RemoveFacetFromObjectInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "RemoveFacetFromObjectInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.SchemaFacet == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaFacet"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	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 validateOpUpdateFacetInput(v *UpdateFacetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateFacetInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AttributeUpdates != nil {
		if err := validateFacetAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateLinkAttributesInput(v *UpdateLinkAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateLinkAttributesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.TypedLinkSpecifier == nil {
		invalidParams.Add(smithy.NewErrParamRequired("TypedLinkSpecifier"))
	} else if v.TypedLinkSpecifier != nil {
		if err := validateTypedLinkSpecifier(v.TypedLinkSpecifier); err != nil {
			invalidParams.AddNested("TypedLinkSpecifier", err.(smithy.InvalidParamsError))
		}
	}
	if v.AttributeUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeUpdates"))
	} else if v.AttributeUpdates != nil {
		if err := validateLinkAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpdateObjectAttributesInput(v *UpdateObjectAttributesInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateObjectAttributesInput"}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if v.ObjectReference == nil {
		invalidParams.Add(smithy.NewErrParamRequired("ObjectReference"))
	}
	if v.AttributeUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeUpdates"))
	} else if v.AttributeUpdates != nil {
		if err := validateObjectAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

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

func validateOpUpdateTypedLinkFacetInput(v *UpdateTypedLinkFacetInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpdateTypedLinkFacetInput"}
	if v.SchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("SchemaArn"))
	}
	if v.Name == nil {
		invalidParams.Add(smithy.NewErrParamRequired("Name"))
	}
	if v.AttributeUpdates == nil {
		invalidParams.Add(smithy.NewErrParamRequired("AttributeUpdates"))
	} else if v.AttributeUpdates != nil {
		if err := validateTypedLinkFacetAttributeUpdateList(v.AttributeUpdates); err != nil {
			invalidParams.AddNested("AttributeUpdates", err.(smithy.InvalidParamsError))
		}
	}
	if v.IdentityAttributeOrder == nil {
		invalidParams.Add(smithy.NewErrParamRequired("IdentityAttributeOrder"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpgradeAppliedSchemaInput(v *UpgradeAppliedSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpgradeAppliedSchemaInput"}
	if v.PublishedSchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublishedSchemaArn"))
	}
	if v.DirectoryArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DirectoryArn"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}

func validateOpUpgradePublishedSchemaInput(v *UpgradePublishedSchemaInput) error {
	if v == nil {
		return nil
	}
	invalidParams := smithy.InvalidParamsError{Context: "UpgradePublishedSchemaInput"}
	if v.DevelopmentSchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("DevelopmentSchemaArn"))
	}
	if v.PublishedSchemaArn == nil {
		invalidParams.Add(smithy.NewErrParamRequired("PublishedSchemaArn"))
	}
	if v.MinorVersion == nil {
		invalidParams.Add(smithy.NewErrParamRequired("MinorVersion"))
	}
	if invalidParams.Len() > 0 {
		return invalidParams
	} else {
		return nil
	}
}