@aws-sdk/client-clouddirectory 3.50.0 → 3.53.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,2996 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CloudDirectoryServiceException as __BaseException } from "./CloudDirectoryServiceException";
+
+export declare class AccessDeniedException extends __BaseException {
+    readonly name: "AccessDeniedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<AccessDeniedException, __BaseException>);
+}
+
+export interface AttributeKey {
+    
+    SchemaArn: string | undefined;
+    
+    FacetName: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace AttributeKey {
+    
+    const filterSensitiveLog: (obj: AttributeKey) => any;
+}
+
+export declare type TypedAttributeValue = TypedAttributeValue.BinaryValueMember | TypedAttributeValue.BooleanValueMember | TypedAttributeValue.DatetimeValueMember | TypedAttributeValue.NumberValueMember | TypedAttributeValue.StringValueMember | TypedAttributeValue.$UnknownMember;
+export declare namespace TypedAttributeValue {
+    
+    interface StringValueMember {
+        StringValue: string;
+        BinaryValue?: never;
+        BooleanValue?: never;
+        NumberValue?: never;
+        DatetimeValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BinaryValueMember {
+        StringValue?: never;
+        BinaryValue: Uint8Array;
+        BooleanValue?: never;
+        NumberValue?: never;
+        DatetimeValue?: never;
+        $unknown?: never;
+    }
+    
+    interface BooleanValueMember {
+        StringValue?: never;
+        BinaryValue?: never;
+        BooleanValue: boolean;
+        NumberValue?: never;
+        DatetimeValue?: never;
+        $unknown?: never;
+    }
+    
+    interface NumberValueMember {
+        StringValue?: never;
+        BinaryValue?: never;
+        BooleanValue?: never;
+        NumberValue: string;
+        DatetimeValue?: never;
+        $unknown?: never;
+    }
+    
+    interface DatetimeValueMember {
+        StringValue?: never;
+        BinaryValue?: never;
+        BooleanValue?: never;
+        NumberValue?: never;
+        DatetimeValue: Date;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        StringValue?: never;
+        BinaryValue?: never;
+        BooleanValue?: never;
+        NumberValue?: never;
+        DatetimeValue?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        StringValue: (value: string) => T;
+        BinaryValue: (value: Uint8Array) => T;
+        BooleanValue: (value: boolean) => T;
+        NumberValue: (value: string) => T;
+        DatetimeValue: (value: Date) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: TypedAttributeValue, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: TypedAttributeValue) => any;
+}
+
+export interface AttributeKeyAndValue {
+    
+    Key: AttributeKey | undefined;
+    
+    Value: TypedAttributeValue | undefined;
+}
+export declare namespace AttributeKeyAndValue {
+    
+    const filterSensitiveLog: (obj: AttributeKeyAndValue) => any;
+}
+
+export interface ObjectReference {
+    
+    Selector?: string;
+}
+export declare namespace ObjectReference {
+    
+    const filterSensitiveLog: (obj: ObjectReference) => any;
+}
+
+export interface SchemaFacet {
+    
+    SchemaArn?: string;
+    
+    FacetName?: string;
+}
+export declare namespace SchemaFacet {
+    
+    const filterSensitiveLog: (obj: SchemaFacet) => any;
+}
+export interface AddFacetToObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    ObjectAttributeList?: AttributeKeyAndValue[];
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace AddFacetToObjectRequest {
+    
+    const filterSensitiveLog: (obj: AddFacetToObjectRequest) => any;
+}
+export interface AddFacetToObjectResponse {
+}
+export declare namespace AddFacetToObjectResponse {
+    
+    const filterSensitiveLog: (obj: AddFacetToObjectResponse) => any;
+}
+
+export declare class DirectoryNotEnabledException extends __BaseException {
+    readonly name: "DirectoryNotEnabledException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DirectoryNotEnabledException, __BaseException>);
+}
+
+export declare class FacetValidationException extends __BaseException {
+    readonly name: "FacetValidationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FacetValidationException, __BaseException>);
+}
+
+export declare class InternalServiceException extends __BaseException {
+    readonly name: "InternalServiceException";
+    readonly $fault: "server";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InternalServiceException, __BaseException>);
+}
+
+export declare class InvalidArnException extends __BaseException {
+    readonly name: "InvalidArnException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidArnException, __BaseException>);
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class RetryableConflictException extends __BaseException {
+    readonly name: "RetryableConflictException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RetryableConflictException, __BaseException>);
+}
+
+export declare class ValidationException extends __BaseException {
+    readonly name: "ValidationException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ValidationException, __BaseException>);
+}
+export interface ApplySchemaRequest {
+    
+    PublishedSchemaArn: string | undefined;
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace ApplySchemaRequest {
+    
+    const filterSensitiveLog: (obj: ApplySchemaRequest) => any;
+}
+export interface ApplySchemaResponse {
+    
+    AppliedSchemaArn?: string;
+    
+    DirectoryArn?: string;
+}
+export declare namespace ApplySchemaResponse {
+    
+    const filterSensitiveLog: (obj: ApplySchemaResponse) => any;
+}
+
+export declare class InvalidAttachmentException extends __BaseException {
+    readonly name: "InvalidAttachmentException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidAttachmentException, __BaseException>);
+}
+
+export declare class SchemaAlreadyExistsException extends __BaseException {
+    readonly name: "SchemaAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SchemaAlreadyExistsException, __BaseException>);
+}
+export interface AttachObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ParentReference: ObjectReference | undefined;
+    
+    ChildReference: ObjectReference | undefined;
+    
+    LinkName: string | undefined;
+}
+export declare namespace AttachObjectRequest {
+    
+    const filterSensitiveLog: (obj: AttachObjectRequest) => any;
+}
+export interface AttachObjectResponse {
+    
+    AttachedObjectIdentifier?: string;
+}
+export declare namespace AttachObjectResponse {
+    
+    const filterSensitiveLog: (obj: AttachObjectResponse) => any;
+}
+
+export declare class LinkNameAlreadyInUseException extends __BaseException {
+    readonly name: "LinkNameAlreadyInUseException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<LinkNameAlreadyInUseException, __BaseException>);
+}
+export interface AttachPolicyRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace AttachPolicyRequest {
+    
+    const filterSensitiveLog: (obj: AttachPolicyRequest) => any;
+}
+export interface AttachPolicyResponse {
+}
+export declare namespace AttachPolicyResponse {
+    
+    const filterSensitiveLog: (obj: AttachPolicyResponse) => any;
+}
+
+export declare class NotPolicyException extends __BaseException {
+    readonly name: "NotPolicyException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotPolicyException, __BaseException>);
+}
+export interface AttachToIndexRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    IndexReference: ObjectReference | undefined;
+    
+    TargetReference: ObjectReference | undefined;
+}
+export declare namespace AttachToIndexRequest {
+    
+    const filterSensitiveLog: (obj: AttachToIndexRequest) => any;
+}
+export interface AttachToIndexResponse {
+    
+    AttachedObjectIdentifier?: string;
+}
+export declare namespace AttachToIndexResponse {
+    
+    const filterSensitiveLog: (obj: AttachToIndexResponse) => any;
+}
+
+export declare class IndexedAttributeMissingException extends __BaseException {
+    readonly name: "IndexedAttributeMissingException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IndexedAttributeMissingException, __BaseException>);
+}
+
+export declare class NotIndexException extends __BaseException {
+    readonly name: "NotIndexException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotIndexException, __BaseException>);
+}
+
+export interface AttributeNameAndValue {
+    
+    AttributeName: string | undefined;
+    
+    Value: TypedAttributeValue | undefined;
+}
+export declare namespace AttributeNameAndValue {
+    
+    const filterSensitiveLog: (obj: AttributeNameAndValue) => any;
+}
+
+export interface TypedLinkSchemaAndFacetName {
+    
+    SchemaArn: string | undefined;
+    
+    TypedLinkName: string | undefined;
+}
+export declare namespace TypedLinkSchemaAndFacetName {
+    
+    const filterSensitiveLog: (obj: TypedLinkSchemaAndFacetName) => any;
+}
+export interface AttachTypedLinkRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    SourceObjectReference: ObjectReference | undefined;
+    
+    TargetObjectReference: ObjectReference | undefined;
+    
+    TypedLinkFacet: TypedLinkSchemaAndFacetName | undefined;
+    
+    Attributes: AttributeNameAndValue[] | undefined;
+}
+export declare namespace AttachTypedLinkRequest {
+    
+    const filterSensitiveLog: (obj: AttachTypedLinkRequest) => any;
+}
+
+export interface TypedLinkSpecifier {
+    
+    TypedLinkFacet: TypedLinkSchemaAndFacetName | undefined;
+    
+    SourceObjectReference: ObjectReference | undefined;
+    
+    TargetObjectReference: ObjectReference | undefined;
+    
+    IdentityAttributeValues: AttributeNameAndValue[] | undefined;
+}
+export declare namespace TypedLinkSpecifier {
+    
+    const filterSensitiveLog: (obj: TypedLinkSpecifier) => any;
+}
+export interface AttachTypedLinkResponse {
+    
+    TypedLinkSpecifier?: TypedLinkSpecifier;
+}
+export declare namespace AttachTypedLinkResponse {
+    
+    const filterSensitiveLog: (obj: AttachTypedLinkResponse) => any;
+}
+export declare enum ConsistencyLevel {
+    EVENTUAL = "EVENTUAL",
+    SERIALIZABLE = "SERIALIZABLE"
+}
+
+export interface BatchGetLinkAttributes {
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+    
+    AttributeNames: string[] | undefined;
+}
+export declare namespace BatchGetLinkAttributes {
+    
+    const filterSensitiveLog: (obj: BatchGetLinkAttributes) => any;
+}
+
+export interface BatchGetObjectAttributes {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    AttributeNames: string[] | undefined;
+}
+export declare namespace BatchGetObjectAttributes {
+    
+    const filterSensitiveLog: (obj: BatchGetObjectAttributes) => any;
+}
+
+export interface BatchGetObjectInformation {
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchGetObjectInformation {
+    
+    const filterSensitiveLog: (obj: BatchGetObjectInformation) => any;
+}
+
+export interface BatchListAttachedIndices {
+    
+    TargetReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListAttachedIndices {
+    
+    const filterSensitiveLog: (obj: BatchListAttachedIndices) => any;
+}
+export declare enum RangeMode {
+    EXCLUSIVE = "EXCLUSIVE",
+    FIRST = "FIRST",
+    INCLUSIVE = "INCLUSIVE",
+    LAST = "LAST",
+    LAST_BEFORE_MISSING_VALUES = "LAST_BEFORE_MISSING_VALUES"
+}
+
+export interface TypedAttributeValueRange {
+    
+    StartMode: RangeMode | string | undefined;
+    
+    StartValue?: TypedAttributeValue;
+    
+    EndMode: RangeMode | string | undefined;
+    
+    EndValue?: TypedAttributeValue;
+}
+export declare namespace TypedAttributeValueRange {
+    
+    const filterSensitiveLog: (obj: TypedAttributeValueRange) => any;
+}
+
+export interface TypedLinkAttributeRange {
+    
+    AttributeName?: string;
+    
+    Range: TypedAttributeValueRange | undefined;
+}
+export declare namespace TypedLinkAttributeRange {
+    
+    const filterSensitiveLog: (obj: TypedLinkAttributeRange) => any;
+}
+
+export interface BatchListIncomingTypedLinks {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    FilterAttributeRanges?: TypedLinkAttributeRange[];
+    
+    FilterTypedLink?: TypedLinkSchemaAndFacetName;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListIncomingTypedLinks {
+    
+    const filterSensitiveLog: (obj: BatchListIncomingTypedLinks) => any;
+}
+
+export interface ObjectAttributeRange {
+    
+    AttributeKey?: AttributeKey;
+    
+    Range?: TypedAttributeValueRange;
+}
+export declare namespace ObjectAttributeRange {
+    
+    const filterSensitiveLog: (obj: ObjectAttributeRange) => any;
+}
+
+export interface BatchListIndex {
+    
+    RangesOnIndexedValues?: ObjectAttributeRange[];
+    
+    IndexReference: ObjectReference | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace BatchListIndex {
+    
+    const filterSensitiveLog: (obj: BatchListIndex) => any;
+}
+
+export interface BatchListObjectAttributes {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    FacetFilter?: SchemaFacet;
+}
+export declare namespace BatchListObjectAttributes {
+    
+    const filterSensitiveLog: (obj: BatchListObjectAttributes) => any;
+}
+
+export interface BatchListObjectChildren {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListObjectChildren {
+    
+    const filterSensitiveLog: (obj: BatchListObjectChildren) => any;
+}
+
+export interface BatchListObjectParentPaths {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListObjectParentPaths {
+    
+    const filterSensitiveLog: (obj: BatchListObjectParentPaths) => any;
+}
+
+export interface BatchListObjectParents {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListObjectParents {
+    
+    const filterSensitiveLog: (obj: BatchListObjectParents) => any;
+}
+
+export interface BatchListObjectPolicies {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListObjectPolicies {
+    
+    const filterSensitiveLog: (obj: BatchListObjectPolicies) => any;
+}
+
+export interface BatchListOutgoingTypedLinks {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    FilterAttributeRanges?: TypedLinkAttributeRange[];
+    
+    FilterTypedLink?: TypedLinkSchemaAndFacetName;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListOutgoingTypedLinks {
+    
+    const filterSensitiveLog: (obj: BatchListOutgoingTypedLinks) => any;
+}
+
+export interface BatchListPolicyAttachments {
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchListPolicyAttachments {
+    
+    const filterSensitiveLog: (obj: BatchListPolicyAttachments) => any;
+}
+
+export interface BatchLookupPolicy {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace BatchLookupPolicy {
+    
+    const filterSensitiveLog: (obj: BatchLookupPolicy) => any;
+}
+
+export interface BatchReadOperation {
+    
+    ListObjectAttributes?: BatchListObjectAttributes;
+    
+    ListObjectChildren?: BatchListObjectChildren;
+    
+    ListAttachedIndices?: BatchListAttachedIndices;
+    
+    ListObjectParentPaths?: BatchListObjectParentPaths;
+    
+    GetObjectInformation?: BatchGetObjectInformation;
+    
+    GetObjectAttributes?: BatchGetObjectAttributes;
+    
+    ListObjectParents?: BatchListObjectParents;
+    
+    ListObjectPolicies?: BatchListObjectPolicies;
+    
+    ListPolicyAttachments?: BatchListPolicyAttachments;
+    
+    LookupPolicy?: BatchLookupPolicy;
+    
+    ListIndex?: BatchListIndex;
+    
+    ListOutgoingTypedLinks?: BatchListOutgoingTypedLinks;
+    
+    ListIncomingTypedLinks?: BatchListIncomingTypedLinks;
+    
+    GetLinkAttributes?: BatchGetLinkAttributes;
+}
+export declare namespace BatchReadOperation {
+    
+    const filterSensitiveLog: (obj: BatchReadOperation) => any;
+}
+export interface BatchReadRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    Operations: BatchReadOperation[] | undefined;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace BatchReadRequest {
+    
+    const filterSensitiveLog: (obj: BatchReadRequest) => any;
+}
+export declare enum BatchReadExceptionType {
+    AccessDeniedException = "AccessDeniedException",
+    CannotListParentOfRootException = "CannotListParentOfRootException",
+    DirectoryNotEnabledException = "DirectoryNotEnabledException",
+    FacetValidationException = "FacetValidationException",
+    InternalServiceException = "InternalServiceException",
+    InvalidArnException = "InvalidArnException",
+    InvalidNextTokenException = "InvalidNextTokenException",
+    LimitExceededException = "LimitExceededException",
+    NotIndexException = "NotIndexException",
+    NotNodeException = "NotNodeException",
+    NotPolicyException = "NotPolicyException",
+    ResourceNotFoundException = "ResourceNotFoundException",
+    ValidationException = "ValidationException"
+}
+
+export interface BatchReadException {
+    
+    Type?: BatchReadExceptionType | string;
+    
+    Message?: string;
+}
+export declare namespace BatchReadException {
+    
+    const filterSensitiveLog: (obj: BatchReadException) => any;
+}
+
+export interface BatchGetLinkAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+}
+export declare namespace BatchGetLinkAttributesResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetLinkAttributesResponse) => any;
+}
+
+export interface BatchGetObjectAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+}
+export declare namespace BatchGetObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetObjectAttributesResponse) => any;
+}
+
+export interface BatchGetObjectInformationResponse {
+    
+    SchemaFacets?: SchemaFacet[];
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace BatchGetObjectInformationResponse {
+    
+    const filterSensitiveLog: (obj: BatchGetObjectInformationResponse) => any;
+}
+
+export interface IndexAttachment {
+    
+    IndexedAttributes?: AttributeKeyAndValue[];
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace IndexAttachment {
+    
+    const filterSensitiveLog: (obj: IndexAttachment) => any;
+}
+
+export interface BatchListAttachedIndicesResponse {
+    
+    IndexAttachments?: IndexAttachment[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListAttachedIndicesResponse {
+    
+    const filterSensitiveLog: (obj: BatchListAttachedIndicesResponse) => any;
+}
+
+export interface BatchListIncomingTypedLinksResponse {
+    
+    LinkSpecifiers?: TypedLinkSpecifier[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListIncomingTypedLinksResponse {
+    
+    const filterSensitiveLog: (obj: BatchListIncomingTypedLinksResponse) => any;
+}
+
+export interface BatchListIndexResponse {
+    
+    IndexAttachments?: IndexAttachment[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListIndexResponse {
+    
+    const filterSensitiveLog: (obj: BatchListIndexResponse) => any;
+}
+
+export interface BatchListObjectAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: BatchListObjectAttributesResponse) => any;
+}
+
+export interface BatchListObjectChildrenResponse {
+    
+    Children?: {
+        [key: string]: string;
+    };
+    
+    NextToken?: string;
+}
+export declare namespace BatchListObjectChildrenResponse {
+    
+    const filterSensitiveLog: (obj: BatchListObjectChildrenResponse) => any;
+}
+
+export interface PathToObjectIdentifiers {
+    
+    Path?: string;
+    
+    ObjectIdentifiers?: string[];
+}
+export declare namespace PathToObjectIdentifiers {
+    
+    const filterSensitiveLog: (obj: PathToObjectIdentifiers) => any;
+}
+
+export interface BatchListObjectParentPathsResponse {
+    
+    PathToObjectIdentifiersList?: PathToObjectIdentifiers[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListObjectParentPathsResponse {
+    
+    const filterSensitiveLog: (obj: BatchListObjectParentPathsResponse) => any;
+}
+
+export interface ObjectIdentifierAndLinkNameTuple {
+    
+    ObjectIdentifier?: string;
+    
+    LinkName?: string;
+}
+export declare namespace ObjectIdentifierAndLinkNameTuple {
+    
+    const filterSensitiveLog: (obj: ObjectIdentifierAndLinkNameTuple) => any;
+}
+
+export interface BatchListObjectParentsResponse {
+    
+    ParentLinks?: ObjectIdentifierAndLinkNameTuple[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListObjectParentsResponse {
+    
+    const filterSensitiveLog: (obj: BatchListObjectParentsResponse) => any;
+}
+
+export interface BatchListObjectPoliciesResponse {
+    
+    AttachedPolicyIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListObjectPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: BatchListObjectPoliciesResponse) => any;
+}
+
+export interface BatchListOutgoingTypedLinksResponse {
+    
+    TypedLinkSpecifiers?: TypedLinkSpecifier[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListOutgoingTypedLinksResponse {
+    
+    const filterSensitiveLog: (obj: BatchListOutgoingTypedLinksResponse) => any;
+}
+
+export interface BatchListPolicyAttachmentsResponse {
+    
+    ObjectIdentifiers?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchListPolicyAttachmentsResponse {
+    
+    const filterSensitiveLog: (obj: BatchListPolicyAttachmentsResponse) => any;
+}
+
+export interface PolicyAttachment {
+    
+    PolicyId?: string;
+    
+    ObjectIdentifier?: string;
+    
+    PolicyType?: string;
+}
+export declare namespace PolicyAttachment {
+    
+    const filterSensitiveLog: (obj: PolicyAttachment) => any;
+}
+
+export interface PolicyToPath {
+    
+    Path?: string;
+    
+    Policies?: PolicyAttachment[];
+}
+export declare namespace PolicyToPath {
+    
+    const filterSensitiveLog: (obj: PolicyToPath) => any;
+}
+
+export interface BatchLookupPolicyResponse {
+    
+    PolicyToPathList?: PolicyToPath[];
+    
+    NextToken?: string;
+}
+export declare namespace BatchLookupPolicyResponse {
+    
+    const filterSensitiveLog: (obj: BatchLookupPolicyResponse) => any;
+}
+
+export interface BatchReadSuccessfulResponse {
+    
+    ListObjectAttributes?: BatchListObjectAttributesResponse;
+    
+    ListObjectChildren?: BatchListObjectChildrenResponse;
+    
+    GetObjectInformation?: BatchGetObjectInformationResponse;
+    
+    GetObjectAttributes?: BatchGetObjectAttributesResponse;
+    
+    ListAttachedIndices?: BatchListAttachedIndicesResponse;
+    
+    ListObjectParentPaths?: BatchListObjectParentPathsResponse;
+    
+    ListObjectPolicies?: BatchListObjectPoliciesResponse;
+    
+    ListPolicyAttachments?: BatchListPolicyAttachmentsResponse;
+    
+    LookupPolicy?: BatchLookupPolicyResponse;
+    
+    ListIndex?: BatchListIndexResponse;
+    
+    ListOutgoingTypedLinks?: BatchListOutgoingTypedLinksResponse;
+    
+    ListIncomingTypedLinks?: BatchListIncomingTypedLinksResponse;
+    
+    GetLinkAttributes?: BatchGetLinkAttributesResponse;
+    
+    ListObjectParents?: BatchListObjectParentsResponse;
+}
+export declare namespace BatchReadSuccessfulResponse {
+    
+    const filterSensitiveLog: (obj: BatchReadSuccessfulResponse) => any;
+}
+
+export interface BatchReadOperationResponse {
+    
+    SuccessfulResponse?: BatchReadSuccessfulResponse;
+    
+    ExceptionResponse?: BatchReadException;
+}
+export declare namespace BatchReadOperationResponse {
+    
+    const filterSensitiveLog: (obj: BatchReadOperationResponse) => any;
+}
+export interface BatchReadResponse {
+    
+    Responses?: BatchReadOperationResponse[];
+}
+export declare namespace BatchReadResponse {
+    
+    const filterSensitiveLog: (obj: BatchReadResponse) => any;
+}
+export declare enum BatchWriteExceptionType {
+    AccessDeniedException = "AccessDeniedException",
+    DirectoryNotEnabledException = "DirectoryNotEnabledException",
+    FacetValidationException = "FacetValidationException",
+    IndexedAttributeMissingException = "IndexedAttributeMissingException",
+    InternalServiceException = "InternalServiceException",
+    InvalidArnException = "InvalidArnException",
+    InvalidAttachmentException = "InvalidAttachmentException",
+    LimitExceededException = "LimitExceededException",
+    LinkNameAlreadyInUseException = "LinkNameAlreadyInUseException",
+    NotIndexException = "NotIndexException",
+    NotNodeException = "NotNodeException",
+    NotPolicyException = "NotPolicyException",
+    ObjectAlreadyDetachedException = "ObjectAlreadyDetachedException",
+    ObjectNotDetachedException = "ObjectNotDetachedException",
+    ResourceNotFoundException = "ResourceNotFoundException",
+    StillContainsLinksException = "StillContainsLinksException",
+    UnsupportedIndexTypeException = "UnsupportedIndexTypeException",
+    ValidationException = "ValidationException"
+}
+
+export declare class BatchWriteException extends __BaseException {
+    readonly name: "BatchWriteException";
+    readonly $fault: "client";
+    Index?: number;
+    Type?: BatchWriteExceptionType | string;
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<BatchWriteException, __BaseException>);
+}
+
+export interface BatchAddFacetToObject {
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    ObjectAttributeList: AttributeKeyAndValue[] | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchAddFacetToObject {
+    
+    const filterSensitiveLog: (obj: BatchAddFacetToObject) => any;
+}
+
+export interface BatchAttachObject {
+    
+    ParentReference: ObjectReference | undefined;
+    
+    ChildReference: ObjectReference | undefined;
+    
+    LinkName: string | undefined;
+}
+export declare namespace BatchAttachObject {
+    
+    const filterSensitiveLog: (obj: BatchAttachObject) => any;
+}
+
+export interface BatchAttachPolicy {
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchAttachPolicy {
+    
+    const filterSensitiveLog: (obj: BatchAttachPolicy) => any;
+}
+
+export interface BatchAttachToIndex {
+    
+    IndexReference: ObjectReference | undefined;
+    
+    TargetReference: ObjectReference | undefined;
+}
+export declare namespace BatchAttachToIndex {
+    
+    const filterSensitiveLog: (obj: BatchAttachToIndex) => any;
+}
+
+export interface BatchAttachTypedLink {
+    
+    SourceObjectReference: ObjectReference | undefined;
+    
+    TargetObjectReference: ObjectReference | undefined;
+    
+    TypedLinkFacet: TypedLinkSchemaAndFacetName | undefined;
+    
+    Attributes: AttributeNameAndValue[] | undefined;
+}
+export declare namespace BatchAttachTypedLink {
+    
+    const filterSensitiveLog: (obj: BatchAttachTypedLink) => any;
+}
+
+export interface BatchCreateIndex {
+    
+    OrderedIndexedAttributeList: AttributeKey[] | undefined;
+    
+    IsUnique: boolean | undefined;
+    
+    ParentReference?: ObjectReference;
+    
+    LinkName?: string;
+    
+    BatchReferenceName?: string;
+}
+export declare namespace BatchCreateIndex {
+    
+    const filterSensitiveLog: (obj: BatchCreateIndex) => any;
+}
+
+export interface BatchCreateObject {
+    
+    SchemaFacet: SchemaFacet[] | undefined;
+    
+    ObjectAttributeList: AttributeKeyAndValue[] | undefined;
+    
+    ParentReference?: ObjectReference;
+    
+    LinkName?: string;
+    
+    BatchReferenceName?: string;
+}
+export declare namespace BatchCreateObject {
+    
+    const filterSensitiveLog: (obj: BatchCreateObject) => any;
+}
+
+export interface BatchDeleteObject {
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchDeleteObject {
+    
+    const filterSensitiveLog: (obj: BatchDeleteObject) => any;
+}
+
+export interface BatchDetachFromIndex {
+    
+    IndexReference: ObjectReference | undefined;
+    
+    TargetReference: ObjectReference | undefined;
+}
+export declare namespace BatchDetachFromIndex {
+    
+    const filterSensitiveLog: (obj: BatchDetachFromIndex) => any;
+}
+
+export interface BatchDetachObject {
+    
+    ParentReference: ObjectReference | undefined;
+    
+    LinkName: string | undefined;
+    
+    BatchReferenceName?: string;
+}
+export declare namespace BatchDetachObject {
+    
+    const filterSensitiveLog: (obj: BatchDetachObject) => any;
+}
+
+export interface BatchDetachPolicy {
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchDetachPolicy {
+    
+    const filterSensitiveLog: (obj: BatchDetachPolicy) => any;
+}
+
+export interface BatchDetachTypedLink {
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+}
+export declare namespace BatchDetachTypedLink {
+    
+    const filterSensitiveLog: (obj: BatchDetachTypedLink) => any;
+}
+
+export interface BatchRemoveFacetFromObject {
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace BatchRemoveFacetFromObject {
+    
+    const filterSensitiveLog: (obj: BatchRemoveFacetFromObject) => any;
+}
+export declare enum UpdateActionType {
+    CREATE_OR_UPDATE = "CREATE_OR_UPDATE",
+    DELETE = "DELETE"
+}
+
+export interface LinkAttributeAction {
+    
+    AttributeActionType?: UpdateActionType | string;
+    
+    AttributeUpdateValue?: TypedAttributeValue;
+}
+export declare namespace LinkAttributeAction {
+    
+    const filterSensitiveLog: (obj: LinkAttributeAction) => any;
+}
+
+export interface LinkAttributeUpdate {
+    
+    AttributeKey?: AttributeKey;
+    
+    AttributeAction?: LinkAttributeAction;
+}
+export declare namespace LinkAttributeUpdate {
+    
+    const filterSensitiveLog: (obj: LinkAttributeUpdate) => any;
+}
+
+export interface BatchUpdateLinkAttributes {
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+    
+    AttributeUpdates: LinkAttributeUpdate[] | undefined;
+}
+export declare namespace BatchUpdateLinkAttributes {
+    
+    const filterSensitiveLog: (obj: BatchUpdateLinkAttributes) => any;
+}
+
+export interface ObjectAttributeAction {
+    
+    ObjectAttributeActionType?: UpdateActionType | string;
+    
+    ObjectAttributeUpdateValue?: TypedAttributeValue;
+}
+export declare namespace ObjectAttributeAction {
+    
+    const filterSensitiveLog: (obj: ObjectAttributeAction) => any;
+}
+
+export interface ObjectAttributeUpdate {
+    
+    ObjectAttributeKey?: AttributeKey;
+    
+    ObjectAttributeAction?: ObjectAttributeAction;
+}
+export declare namespace ObjectAttributeUpdate {
+    
+    const filterSensitiveLog: (obj: ObjectAttributeUpdate) => any;
+}
+
+export interface BatchUpdateObjectAttributes {
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    AttributeUpdates: ObjectAttributeUpdate[] | undefined;
+}
+export declare namespace BatchUpdateObjectAttributes {
+    
+    const filterSensitiveLog: (obj: BatchUpdateObjectAttributes) => any;
+}
+
+export interface BatchWriteOperation {
+    
+    CreateObject?: BatchCreateObject;
+    
+    AttachObject?: BatchAttachObject;
+    
+    DetachObject?: BatchDetachObject;
+    
+    UpdateObjectAttributes?: BatchUpdateObjectAttributes;
+    
+    DeleteObject?: BatchDeleteObject;
+    
+    AddFacetToObject?: BatchAddFacetToObject;
+    
+    RemoveFacetFromObject?: BatchRemoveFacetFromObject;
+    
+    AttachPolicy?: BatchAttachPolicy;
+    
+    DetachPolicy?: BatchDetachPolicy;
+    
+    CreateIndex?: BatchCreateIndex;
+    
+    AttachToIndex?: BatchAttachToIndex;
+    
+    DetachFromIndex?: BatchDetachFromIndex;
+    
+    AttachTypedLink?: BatchAttachTypedLink;
+    
+    DetachTypedLink?: BatchDetachTypedLink;
+    
+    UpdateLinkAttributes?: BatchUpdateLinkAttributes;
+}
+export declare namespace BatchWriteOperation {
+    
+    const filterSensitiveLog: (obj: BatchWriteOperation) => any;
+}
+export interface BatchWriteRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    Operations: BatchWriteOperation[] | undefined;
+}
+export declare namespace BatchWriteRequest {
+    
+    const filterSensitiveLog: (obj: BatchWriteRequest) => any;
+}
+
+export interface BatchAddFacetToObjectResponse {
+}
+export declare namespace BatchAddFacetToObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchAddFacetToObjectResponse) => any;
+}
+
+export interface BatchAttachObjectResponse {
+    
+    attachedObjectIdentifier?: string;
+}
+export declare namespace BatchAttachObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchAttachObjectResponse) => any;
+}
+
+export interface BatchAttachPolicyResponse {
+}
+export declare namespace BatchAttachPolicyResponse {
+    
+    const filterSensitiveLog: (obj: BatchAttachPolicyResponse) => any;
+}
+
+export interface BatchAttachToIndexResponse {
+    
+    AttachedObjectIdentifier?: string;
+}
+export declare namespace BatchAttachToIndexResponse {
+    
+    const filterSensitiveLog: (obj: BatchAttachToIndexResponse) => any;
+}
+
+export interface BatchAttachTypedLinkResponse {
+    
+    TypedLinkSpecifier?: TypedLinkSpecifier;
+}
+export declare namespace BatchAttachTypedLinkResponse {
+    
+    const filterSensitiveLog: (obj: BatchAttachTypedLinkResponse) => any;
+}
+
+export interface BatchCreateIndexResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace BatchCreateIndexResponse {
+    
+    const filterSensitiveLog: (obj: BatchCreateIndexResponse) => any;
+}
+
+export interface BatchCreateObjectResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace BatchCreateObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchCreateObjectResponse) => any;
+}
+
+export interface BatchDeleteObjectResponse {
+}
+export declare namespace BatchDeleteObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchDeleteObjectResponse) => any;
+}
+
+export interface BatchDetachFromIndexResponse {
+    
+    DetachedObjectIdentifier?: string;
+}
+export declare namespace BatchDetachFromIndexResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetachFromIndexResponse) => any;
+}
+
+export interface BatchDetachObjectResponse {
+    
+    detachedObjectIdentifier?: string;
+}
+export declare namespace BatchDetachObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetachObjectResponse) => any;
+}
+
+export interface BatchDetachPolicyResponse {
+}
+export declare namespace BatchDetachPolicyResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetachPolicyResponse) => any;
+}
+
+export interface BatchDetachTypedLinkResponse {
+}
+export declare namespace BatchDetachTypedLinkResponse {
+    
+    const filterSensitiveLog: (obj: BatchDetachTypedLinkResponse) => any;
+}
+
+export interface BatchRemoveFacetFromObjectResponse {
+}
+export declare namespace BatchRemoveFacetFromObjectResponse {
+    
+    const filterSensitiveLog: (obj: BatchRemoveFacetFromObjectResponse) => any;
+}
+
+export interface BatchUpdateLinkAttributesResponse {
+}
+export declare namespace BatchUpdateLinkAttributesResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdateLinkAttributesResponse) => any;
+}
+
+export interface BatchUpdateObjectAttributesResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace BatchUpdateObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: BatchUpdateObjectAttributesResponse) => any;
+}
+
+export interface BatchWriteOperationResponse {
+    
+    CreateObject?: BatchCreateObjectResponse;
+    
+    AttachObject?: BatchAttachObjectResponse;
+    
+    DetachObject?: BatchDetachObjectResponse;
+    
+    UpdateObjectAttributes?: BatchUpdateObjectAttributesResponse;
+    
+    DeleteObject?: BatchDeleteObjectResponse;
+    
+    AddFacetToObject?: BatchAddFacetToObjectResponse;
+    
+    RemoveFacetFromObject?: BatchRemoveFacetFromObjectResponse;
+    
+    AttachPolicy?: BatchAttachPolicyResponse;
+    
+    DetachPolicy?: BatchDetachPolicyResponse;
+    
+    CreateIndex?: BatchCreateIndexResponse;
+    
+    AttachToIndex?: BatchAttachToIndexResponse;
+    
+    DetachFromIndex?: BatchDetachFromIndexResponse;
+    
+    AttachTypedLink?: BatchAttachTypedLinkResponse;
+    
+    DetachTypedLink?: BatchDetachTypedLinkResponse;
+    
+    UpdateLinkAttributes?: BatchUpdateLinkAttributesResponse;
+}
+export declare namespace BatchWriteOperationResponse {
+    
+    const filterSensitiveLog: (obj: BatchWriteOperationResponse) => any;
+}
+export interface BatchWriteResponse {
+    
+    Responses?: BatchWriteOperationResponse[];
+}
+export declare namespace BatchWriteResponse {
+    
+    const filterSensitiveLog: (obj: BatchWriteResponse) => any;
+}
+export interface CreateDirectoryRequest {
+    
+    Name: string | undefined;
+    
+    SchemaArn: string | undefined;
+}
+export declare namespace CreateDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: CreateDirectoryRequest) => any;
+}
+export interface CreateDirectoryResponse {
+    
+    DirectoryArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    ObjectIdentifier: string | undefined;
+    
+    AppliedSchemaArn: string | undefined;
+}
+export declare namespace CreateDirectoryResponse {
+    
+    const filterSensitiveLog: (obj: CreateDirectoryResponse) => any;
+}
+
+export declare class DirectoryAlreadyExistsException extends __BaseException {
+    readonly name: "DirectoryAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DirectoryAlreadyExistsException, __BaseException>);
+}
+export declare enum RuleType {
+    BINARY_LENGTH = "BINARY_LENGTH",
+    NUMBER_COMPARISON = "NUMBER_COMPARISON",
+    STRING_FROM_SET = "STRING_FROM_SET",
+    STRING_LENGTH = "STRING_LENGTH"
+}
+
+export interface Rule {
+    
+    Type?: RuleType | string;
+    
+    Parameters?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Rule {
+    
+    const filterSensitiveLog: (obj: Rule) => any;
+}
+export declare enum FacetAttributeType {
+    BINARY = "BINARY",
+    BOOLEAN = "BOOLEAN",
+    DATETIME = "DATETIME",
+    NUMBER = "NUMBER",
+    STRING = "STRING",
+    VARIANT = "VARIANT"
+}
+
+export interface FacetAttributeDefinition {
+    
+    Type: FacetAttributeType | string | undefined;
+    
+    DefaultValue?: TypedAttributeValue;
+    
+    IsImmutable?: boolean;
+    
+    Rules?: {
+        [key: string]: Rule;
+    };
+}
+export declare namespace FacetAttributeDefinition {
+    
+    const filterSensitiveLog: (obj: FacetAttributeDefinition) => any;
+}
+
+export interface FacetAttributeReference {
+    
+    TargetFacetName: string | undefined;
+    
+    TargetAttributeName: string | undefined;
+}
+export declare namespace FacetAttributeReference {
+    
+    const filterSensitiveLog: (obj: FacetAttributeReference) => any;
+}
+export declare enum RequiredAttributeBehavior {
+    NOT_REQUIRED = "NOT_REQUIRED",
+    REQUIRED_ALWAYS = "REQUIRED_ALWAYS"
+}
+
+export interface FacetAttribute {
+    
+    Name: string | undefined;
+    
+    AttributeDefinition?: FacetAttributeDefinition;
+    
+    AttributeReference?: FacetAttributeReference;
+    
+    RequiredBehavior?: RequiredAttributeBehavior | string;
+}
+export declare namespace FacetAttribute {
+    
+    const filterSensitiveLog: (obj: FacetAttribute) => any;
+}
+export declare enum FacetStyle {
+    DYNAMIC = "DYNAMIC",
+    STATIC = "STATIC"
+}
+export declare enum ObjectType {
+    INDEX = "INDEX",
+    LEAF_NODE = "LEAF_NODE",
+    NODE = "NODE",
+    POLICY = "POLICY"
+}
+export interface CreateFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    Attributes?: FacetAttribute[];
+    
+    ObjectType?: ObjectType | string;
+    
+    FacetStyle?: FacetStyle | string;
+}
+export declare namespace CreateFacetRequest {
+    
+    const filterSensitiveLog: (obj: CreateFacetRequest) => any;
+}
+export interface CreateFacetResponse {
+}
+export declare namespace CreateFacetResponse {
+    
+    const filterSensitiveLog: (obj: CreateFacetResponse) => any;
+}
+
+export declare class FacetAlreadyExistsException extends __BaseException {
+    readonly name: "FacetAlreadyExistsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FacetAlreadyExistsException, __BaseException>);
+}
+
+export declare class InvalidRuleException extends __BaseException {
+    readonly name: "InvalidRuleException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidRuleException, __BaseException>);
+}
+export interface CreateIndexRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    OrderedIndexedAttributeList: AttributeKey[] | undefined;
+    
+    IsUnique: boolean | undefined;
+    
+    ParentReference?: ObjectReference;
+    
+    LinkName?: string;
+}
+export declare namespace CreateIndexRequest {
+    
+    const filterSensitiveLog: (obj: CreateIndexRequest) => any;
+}
+export interface CreateIndexResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace CreateIndexResponse {
+    
+    const filterSensitiveLog: (obj: CreateIndexResponse) => any;
+}
+
+export declare class UnsupportedIndexTypeException extends __BaseException {
+    readonly name: "UnsupportedIndexTypeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<UnsupportedIndexTypeException, __BaseException>);
+}
+export interface CreateObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    SchemaFacets: SchemaFacet[] | undefined;
+    
+    ObjectAttributeList?: AttributeKeyAndValue[];
+    
+    ParentReference?: ObjectReference;
+    
+    LinkName?: string;
+}
+export declare namespace CreateObjectRequest {
+    
+    const filterSensitiveLog: (obj: CreateObjectRequest) => any;
+}
+export interface CreateObjectResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace CreateObjectResponse {
+    
+    const filterSensitiveLog: (obj: CreateObjectResponse) => any;
+}
+export interface CreateSchemaRequest {
+    
+    Name: string | undefined;
+}
+export declare namespace CreateSchemaRequest {
+    
+    const filterSensitiveLog: (obj: CreateSchemaRequest) => any;
+}
+export interface CreateSchemaResponse {
+    
+    SchemaArn?: string;
+}
+export declare namespace CreateSchemaResponse {
+    
+    const filterSensitiveLog: (obj: CreateSchemaResponse) => any;
+}
+
+export interface TypedLinkAttributeDefinition {
+    
+    Name: string | undefined;
+    
+    Type: FacetAttributeType | string | undefined;
+    
+    DefaultValue?: TypedAttributeValue;
+    
+    IsImmutable?: boolean;
+    
+    Rules?: {
+        [key: string]: Rule;
+    };
+    
+    RequiredBehavior: RequiredAttributeBehavior | string | undefined;
+}
+export declare namespace TypedLinkAttributeDefinition {
+    
+    const filterSensitiveLog: (obj: TypedLinkAttributeDefinition) => any;
+}
+
+export interface TypedLinkFacet {
+    
+    Name: string | undefined;
+    
+    Attributes: TypedLinkAttributeDefinition[] | undefined;
+    
+    IdentityAttributeOrder: string[] | undefined;
+}
+export declare namespace TypedLinkFacet {
+    
+    const filterSensitiveLog: (obj: TypedLinkFacet) => any;
+}
+export interface CreateTypedLinkFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Facet: TypedLinkFacet | undefined;
+}
+export declare namespace CreateTypedLinkFacetRequest {
+    
+    const filterSensitiveLog: (obj: CreateTypedLinkFacetRequest) => any;
+}
+export interface CreateTypedLinkFacetResponse {
+}
+export declare namespace CreateTypedLinkFacetResponse {
+    
+    const filterSensitiveLog: (obj: CreateTypedLinkFacetResponse) => any;
+}
+export interface DeleteDirectoryRequest {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace DeleteDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDirectoryRequest) => any;
+}
+export interface DeleteDirectoryResponse {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace DeleteDirectoryResponse {
+    
+    const filterSensitiveLog: (obj: DeleteDirectoryResponse) => any;
+}
+
+export declare class DirectoryDeletedException extends __BaseException {
+    readonly name: "DirectoryDeletedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DirectoryDeletedException, __BaseException>);
+}
+
+export declare class DirectoryNotDisabledException extends __BaseException {
+    readonly name: "DirectoryNotDisabledException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<DirectoryNotDisabledException, __BaseException>);
+}
+export interface DeleteFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteFacetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteFacetRequest) => any;
+}
+export interface DeleteFacetResponse {
+}
+export declare namespace DeleteFacetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteFacetResponse) => any;
+}
+
+export declare class FacetInUseException extends __BaseException {
+    readonly name: "FacetInUseException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FacetInUseException, __BaseException>);
+}
+
+export declare class FacetNotFoundException extends __BaseException {
+    readonly name: "FacetNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<FacetNotFoundException, __BaseException>);
+}
+export interface DeleteObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace DeleteObjectRequest {
+    
+    const filterSensitiveLog: (obj: DeleteObjectRequest) => any;
+}
+export interface DeleteObjectResponse {
+}
+export declare namespace DeleteObjectResponse {
+    
+    const filterSensitiveLog: (obj: DeleteObjectResponse) => any;
+}
+
+export declare class ObjectNotDetachedException extends __BaseException {
+    readonly name: "ObjectNotDetachedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ObjectNotDetachedException, __BaseException>);
+}
+export interface DeleteSchemaRequest {
+    
+    SchemaArn: string | undefined;
+}
+export declare namespace DeleteSchemaRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSchemaRequest) => any;
+}
+export interface DeleteSchemaResponse {
+    
+    SchemaArn?: string;
+}
+export declare namespace DeleteSchemaResponse {
+    
+    const filterSensitiveLog: (obj: DeleteSchemaResponse) => any;
+}
+
+export declare class StillContainsLinksException extends __BaseException {
+    readonly name: "StillContainsLinksException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<StillContainsLinksException, __BaseException>);
+}
+export interface DeleteTypedLinkFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace DeleteTypedLinkFacetRequest {
+    
+    const filterSensitiveLog: (obj: DeleteTypedLinkFacetRequest) => any;
+}
+export interface DeleteTypedLinkFacetResponse {
+}
+export declare namespace DeleteTypedLinkFacetResponse {
+    
+    const filterSensitiveLog: (obj: DeleteTypedLinkFacetResponse) => any;
+}
+export interface DetachFromIndexRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    IndexReference: ObjectReference | undefined;
+    
+    TargetReference: ObjectReference | undefined;
+}
+export declare namespace DetachFromIndexRequest {
+    
+    const filterSensitiveLog: (obj: DetachFromIndexRequest) => any;
+}
+export interface DetachFromIndexResponse {
+    
+    DetachedObjectIdentifier?: string;
+}
+export declare namespace DetachFromIndexResponse {
+    
+    const filterSensitiveLog: (obj: DetachFromIndexResponse) => any;
+}
+
+export declare class ObjectAlreadyDetachedException extends __BaseException {
+    readonly name: "ObjectAlreadyDetachedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ObjectAlreadyDetachedException, __BaseException>);
+}
+export interface DetachObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ParentReference: ObjectReference | undefined;
+    
+    LinkName: string | undefined;
+}
+export declare namespace DetachObjectRequest {
+    
+    const filterSensitiveLog: (obj: DetachObjectRequest) => any;
+}
+export interface DetachObjectResponse {
+    
+    DetachedObjectIdentifier?: string;
+}
+export declare namespace DetachObjectResponse {
+    
+    const filterSensitiveLog: (obj: DetachObjectResponse) => any;
+}
+
+export declare class NotNodeException extends __BaseException {
+    readonly name: "NotNodeException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NotNodeException, __BaseException>);
+}
+export interface DetachPolicyRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace DetachPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DetachPolicyRequest) => any;
+}
+export interface DetachPolicyResponse {
+}
+export declare namespace DetachPolicyResponse {
+    
+    const filterSensitiveLog: (obj: DetachPolicyResponse) => any;
+}
+export interface DetachTypedLinkRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+}
+export declare namespace DetachTypedLinkRequest {
+    
+    const filterSensitiveLog: (obj: DetachTypedLinkRequest) => any;
+}
+export interface DisableDirectoryRequest {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace DisableDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: DisableDirectoryRequest) => any;
+}
+export interface DisableDirectoryResponse {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace DisableDirectoryResponse {
+    
+    const filterSensitiveLog: (obj: DisableDirectoryResponse) => any;
+}
+export interface EnableDirectoryRequest {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace EnableDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: EnableDirectoryRequest) => any;
+}
+export interface EnableDirectoryResponse {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace EnableDirectoryResponse {
+    
+    const filterSensitiveLog: (obj: EnableDirectoryResponse) => any;
+}
+export interface GetAppliedSchemaVersionRequest {
+    
+    SchemaArn: string | undefined;
+}
+export declare namespace GetAppliedSchemaVersionRequest {
+    
+    const filterSensitiveLog: (obj: GetAppliedSchemaVersionRequest) => any;
+}
+export interface GetAppliedSchemaVersionResponse {
+    
+    AppliedSchemaArn?: string;
+}
+export declare namespace GetAppliedSchemaVersionResponse {
+    
+    const filterSensitiveLog: (obj: GetAppliedSchemaVersionResponse) => any;
+}
+export interface GetDirectoryRequest {
+    
+    DirectoryArn: string | undefined;
+}
+export declare namespace GetDirectoryRequest {
+    
+    const filterSensitiveLog: (obj: GetDirectoryRequest) => any;
+}
+export declare enum DirectoryState {
+    DELETED = "DELETED",
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED"
+}
+
+export interface Directory {
+    
+    Name?: string;
+    
+    DirectoryArn?: string;
+    
+    State?: DirectoryState | string;
+    
+    CreationDateTime?: Date;
+}
+export declare namespace Directory {
+    
+    const filterSensitiveLog: (obj: Directory) => any;
+}
+export interface GetDirectoryResponse {
+    
+    Directory: Directory | undefined;
+}
+export declare namespace GetDirectoryResponse {
+    
+    const filterSensitiveLog: (obj: GetDirectoryResponse) => any;
+}
+export interface GetFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace GetFacetRequest {
+    
+    const filterSensitiveLog: (obj: GetFacetRequest) => any;
+}
+
+export interface Facet {
+    
+    Name?: string;
+    
+    ObjectType?: ObjectType | string;
+    
+    FacetStyle?: FacetStyle | string;
+}
+export declare namespace Facet {
+    
+    const filterSensitiveLog: (obj: Facet) => any;
+}
+export interface GetFacetResponse {
+    
+    Facet?: Facet;
+}
+export declare namespace GetFacetResponse {
+    
+    const filterSensitiveLog: (obj: GetFacetResponse) => any;
+}
+export interface GetLinkAttributesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+    
+    AttributeNames: string[] | undefined;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace GetLinkAttributesRequest {
+    
+    const filterSensitiveLog: (obj: GetLinkAttributesRequest) => any;
+}
+export interface GetLinkAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+}
+export declare namespace GetLinkAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetLinkAttributesResponse) => any;
+}
+export interface GetObjectAttributesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    AttributeNames: string[] | undefined;
+}
+export declare namespace GetObjectAttributesRequest {
+    
+    const filterSensitiveLog: (obj: GetObjectAttributesRequest) => any;
+}
+export interface GetObjectAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+}
+export declare namespace GetObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: GetObjectAttributesResponse) => any;
+}
+export interface GetObjectInformationRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace GetObjectInformationRequest {
+    
+    const filterSensitiveLog: (obj: GetObjectInformationRequest) => any;
+}
+export interface GetObjectInformationResponse {
+    
+    SchemaFacets?: SchemaFacet[];
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace GetObjectInformationResponse {
+    
+    const filterSensitiveLog: (obj: GetObjectInformationResponse) => any;
+}
+export interface GetSchemaAsJsonRequest {
+    
+    SchemaArn: string | undefined;
+}
+export declare namespace GetSchemaAsJsonRequest {
+    
+    const filterSensitiveLog: (obj: GetSchemaAsJsonRequest) => any;
+}
+export interface GetSchemaAsJsonResponse {
+    
+    Name?: string;
+    
+    Document?: string;
+}
+export declare namespace GetSchemaAsJsonResponse {
+    
+    const filterSensitiveLog: (obj: GetSchemaAsJsonResponse) => any;
+}
+export interface GetTypedLinkFacetInformationRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace GetTypedLinkFacetInformationRequest {
+    
+    const filterSensitiveLog: (obj: GetTypedLinkFacetInformationRequest) => any;
+}
+export interface GetTypedLinkFacetInformationResponse {
+    
+    IdentityAttributeOrder?: string[];
+}
+export declare namespace GetTypedLinkFacetInformationResponse {
+    
+    const filterSensitiveLog: (obj: GetTypedLinkFacetInformationResponse) => any;
+}
+
+export declare class InvalidNextTokenException extends __BaseException {
+    readonly name: "InvalidNextTokenException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidNextTokenException, __BaseException>);
+}
+export interface ListAppliedSchemaArnsRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    SchemaArn?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListAppliedSchemaArnsRequest {
+    
+    const filterSensitiveLog: (obj: ListAppliedSchemaArnsRequest) => any;
+}
+export interface ListAppliedSchemaArnsResponse {
+    
+    SchemaArns?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAppliedSchemaArnsResponse {
+    
+    const filterSensitiveLog: (obj: ListAppliedSchemaArnsResponse) => any;
+}
+export interface ListAttachedIndicesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    TargetReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListAttachedIndicesRequest {
+    
+    const filterSensitiveLog: (obj: ListAttachedIndicesRequest) => any;
+}
+export interface ListAttachedIndicesResponse {
+    
+    IndexAttachments?: IndexAttachment[];
+    
+    NextToken?: string;
+}
+export declare namespace ListAttachedIndicesResponse {
+    
+    const filterSensitiveLog: (obj: ListAttachedIndicesResponse) => any;
+}
+export interface ListDevelopmentSchemaArnsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListDevelopmentSchemaArnsRequest {
+    
+    const filterSensitiveLog: (obj: ListDevelopmentSchemaArnsRequest) => any;
+}
+export interface ListDevelopmentSchemaArnsResponse {
+    
+    SchemaArns?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListDevelopmentSchemaArnsResponse {
+    
+    const filterSensitiveLog: (obj: ListDevelopmentSchemaArnsResponse) => any;
+}
+export interface ListDirectoriesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    state?: DirectoryState | string;
+}
+export declare namespace ListDirectoriesRequest {
+    
+    const filterSensitiveLog: (obj: ListDirectoriesRequest) => any;
+}
+export interface ListDirectoriesResponse {
+    
+    Directories: Directory[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListDirectoriesResponse {
+    
+    const filterSensitiveLog: (obj: ListDirectoriesResponse) => any;
+}
+export interface ListFacetAttributesRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListFacetAttributesRequest {
+    
+    const filterSensitiveLog: (obj: ListFacetAttributesRequest) => any;
+}
+export interface ListFacetAttributesResponse {
+    
+    Attributes?: FacetAttribute[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFacetAttributesResponse {
+    
+    const filterSensitiveLog: (obj: ListFacetAttributesResponse) => any;
+}
+export interface ListFacetNamesRequest {
+    
+    SchemaArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListFacetNamesRequest {
+    
+    const filterSensitiveLog: (obj: ListFacetNamesRequest) => any;
+}
+export interface ListFacetNamesResponse {
+    
+    FacetNames?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListFacetNamesResponse {
+    
+    const filterSensitiveLog: (obj: ListFacetNamesResponse) => any;
+}
+export interface ListIncomingTypedLinksRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    FilterAttributeRanges?: TypedLinkAttributeRange[];
+    
+    FilterTypedLink?: TypedLinkSchemaAndFacetName;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListIncomingTypedLinksRequest {
+    
+    const filterSensitiveLog: (obj: ListIncomingTypedLinksRequest) => any;
+}
+export interface ListIncomingTypedLinksResponse {
+    
+    LinkSpecifiers?: TypedLinkSpecifier[];
+    
+    NextToken?: string;
+}
+export declare namespace ListIncomingTypedLinksResponse {
+    
+    const filterSensitiveLog: (obj: ListIncomingTypedLinksResponse) => any;
+}
+export interface ListIndexRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    RangesOnIndexedValues?: ObjectAttributeRange[];
+    
+    IndexReference: ObjectReference | undefined;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListIndexRequest {
+    
+    const filterSensitiveLog: (obj: ListIndexRequest) => any;
+}
+export interface ListIndexResponse {
+    
+    IndexAttachments?: IndexAttachment[];
+    
+    NextToken?: string;
+}
+export declare namespace ListIndexResponse {
+    
+    const filterSensitiveLog: (obj: ListIndexResponse) => any;
+}
+export interface ListManagedSchemaArnsRequest {
+    
+    SchemaArn?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListManagedSchemaArnsRequest {
+    
+    const filterSensitiveLog: (obj: ListManagedSchemaArnsRequest) => any;
+}
+export interface ListManagedSchemaArnsResponse {
+    
+    SchemaArns?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListManagedSchemaArnsResponse {
+    
+    const filterSensitiveLog: (obj: ListManagedSchemaArnsResponse) => any;
+}
+export interface ListObjectAttributesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+    
+    FacetFilter?: SchemaFacet;
+}
+export declare namespace ListObjectAttributesRequest {
+    
+    const filterSensitiveLog: (obj: ListObjectAttributesRequest) => any;
+}
+export interface ListObjectAttributesResponse {
+    
+    Attributes?: AttributeKeyAndValue[];
+    
+    NextToken?: string;
+}
+export declare namespace ListObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: ListObjectAttributesResponse) => any;
+}
+export interface ListObjectChildrenRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListObjectChildrenRequest {
+    
+    const filterSensitiveLog: (obj: ListObjectChildrenRequest) => any;
+}
+export interface ListObjectChildrenResponse {
+    
+    Children?: {
+        [key: string]: string;
+    };
+    
+    NextToken?: string;
+}
+export declare namespace ListObjectChildrenResponse {
+    
+    const filterSensitiveLog: (obj: ListObjectChildrenResponse) => any;
+}
+export interface ListObjectParentPathsRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListObjectParentPathsRequest {
+    
+    const filterSensitiveLog: (obj: ListObjectParentPathsRequest) => any;
+}
+export interface ListObjectParentPathsResponse {
+    
+    PathToObjectIdentifiersList?: PathToObjectIdentifiers[];
+    
+    NextToken?: string;
+}
+export declare namespace ListObjectParentPathsResponse {
+    
+    const filterSensitiveLog: (obj: ListObjectParentPathsResponse) => any;
+}
+
+export declare class CannotListParentOfRootException extends __BaseException {
+    readonly name: "CannotListParentOfRootException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CannotListParentOfRootException, __BaseException>);
+}
+export interface ListObjectParentsRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+    
+    IncludeAllLinksToEachParent?: boolean;
+}
+export declare namespace ListObjectParentsRequest {
+    
+    const filterSensitiveLog: (obj: ListObjectParentsRequest) => any;
+}
+export interface ListObjectParentsResponse {
+    
+    Parents?: {
+        [key: string]: string;
+    };
+    
+    NextToken?: string;
+    
+    ParentLinks?: ObjectIdentifierAndLinkNameTuple[];
+}
+export declare namespace ListObjectParentsResponse {
+    
+    const filterSensitiveLog: (obj: ListObjectParentsResponse) => any;
+}
+export interface ListObjectPoliciesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListObjectPoliciesRequest {
+    
+    const filterSensitiveLog: (obj: ListObjectPoliciesRequest) => any;
+}
+export interface ListObjectPoliciesResponse {
+    
+    AttachedPolicyIds?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListObjectPoliciesResponse {
+    
+    const filterSensitiveLog: (obj: ListObjectPoliciesResponse) => any;
+}
+export interface ListOutgoingTypedLinksRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    FilterAttributeRanges?: TypedLinkAttributeRange[];
+    
+    FilterTypedLink?: TypedLinkSchemaAndFacetName;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListOutgoingTypedLinksRequest {
+    
+    const filterSensitiveLog: (obj: ListOutgoingTypedLinksRequest) => any;
+}
+export interface ListOutgoingTypedLinksResponse {
+    
+    TypedLinkSpecifiers?: TypedLinkSpecifier[];
+    
+    NextToken?: string;
+}
+export declare namespace ListOutgoingTypedLinksResponse {
+    
+    const filterSensitiveLog: (obj: ListOutgoingTypedLinksResponse) => any;
+}
+export interface ListPolicyAttachmentsRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    PolicyReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    ConsistencyLevel?: ConsistencyLevel | string;
+}
+export declare namespace ListPolicyAttachmentsRequest {
+    
+    const filterSensitiveLog: (obj: ListPolicyAttachmentsRequest) => any;
+}
+export interface ListPolicyAttachmentsResponse {
+    
+    ObjectIdentifiers?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPolicyAttachmentsResponse {
+    
+    const filterSensitiveLog: (obj: ListPolicyAttachmentsResponse) => any;
+}
+export interface ListPublishedSchemaArnsRequest {
+    
+    SchemaArn?: string;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListPublishedSchemaArnsRequest {
+    
+    const filterSensitiveLog: (obj: ListPublishedSchemaArnsRequest) => any;
+}
+export interface ListPublishedSchemaArnsResponse {
+    
+    SchemaArns?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListPublishedSchemaArnsResponse {
+    
+    const filterSensitiveLog: (obj: ListPublishedSchemaArnsResponse) => any;
+}
+
+export declare class InvalidTaggingRequestException extends __BaseException {
+    readonly name: "InvalidTaggingRequestException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidTaggingRequestException, __BaseException>);
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface ListTypedLinkFacetAttributesRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTypedLinkFacetAttributesRequest {
+    
+    const filterSensitiveLog: (obj: ListTypedLinkFacetAttributesRequest) => any;
+}
+export interface ListTypedLinkFacetAttributesResponse {
+    
+    Attributes?: TypedLinkAttributeDefinition[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTypedLinkFacetAttributesResponse {
+    
+    const filterSensitiveLog: (obj: ListTypedLinkFacetAttributesResponse) => any;
+}
+export interface ListTypedLinkFacetNamesRequest {
+    
+    SchemaArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListTypedLinkFacetNamesRequest {
+    
+    const filterSensitiveLog: (obj: ListTypedLinkFacetNamesRequest) => any;
+}
+export interface ListTypedLinkFacetNamesResponse {
+    
+    FacetNames?: string[];
+    
+    NextToken?: string;
+}
+export declare namespace ListTypedLinkFacetNamesResponse {
+    
+    const filterSensitiveLog: (obj: ListTypedLinkFacetNamesResponse) => any;
+}
+export interface LookupPolicyRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace LookupPolicyRequest {
+    
+    const filterSensitiveLog: (obj: LookupPolicyRequest) => any;
+}
+export interface LookupPolicyResponse {
+    
+    PolicyToPathList?: PolicyToPath[];
+    
+    NextToken?: string;
+}
+export declare namespace LookupPolicyResponse {
+    
+    const filterSensitiveLog: (obj: LookupPolicyResponse) => any;
+}
+export interface PublishSchemaRequest {
+    
+    DevelopmentSchemaArn: string | undefined;
+    
+    Version: string | undefined;
+    
+    MinorVersion?: string;
+    
+    Name?: string;
+}
+export declare namespace PublishSchemaRequest {
+    
+    const filterSensitiveLog: (obj: PublishSchemaRequest) => any;
+}
+export interface PublishSchemaResponse {
+    
+    PublishedSchemaArn?: string;
+}
+export declare namespace PublishSchemaResponse {
+    
+    const filterSensitiveLog: (obj: PublishSchemaResponse) => any;
+}
+
+export declare class SchemaAlreadyPublishedException extends __BaseException {
+    readonly name: "SchemaAlreadyPublishedException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<SchemaAlreadyPublishedException, __BaseException>);
+}
+
+export declare class InvalidSchemaDocException extends __BaseException {
+    readonly name: "InvalidSchemaDocException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSchemaDocException, __BaseException>);
+}
+export interface PutSchemaFromJsonRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Document: string | undefined;
+}
+export declare namespace PutSchemaFromJsonRequest {
+    
+    const filterSensitiveLog: (obj: PutSchemaFromJsonRequest) => any;
+}
+export interface PutSchemaFromJsonResponse {
+    
+    Arn?: string;
+}
+export declare namespace PutSchemaFromJsonResponse {
+    
+    const filterSensitiveLog: (obj: PutSchemaFromJsonResponse) => any;
+}
+export interface RemoveFacetFromObjectRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    SchemaFacet: SchemaFacet | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+}
+export declare namespace RemoveFacetFromObjectRequest {
+    
+    const filterSensitiveLog: (obj: RemoveFacetFromObjectRequest) => any;
+}
+export interface RemoveFacetFromObjectResponse {
+}
+export declare namespace RemoveFacetFromObjectResponse {
+    
+    const filterSensitiveLog: (obj: RemoveFacetFromObjectResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+
+export declare class InvalidFacetUpdateException extends __BaseException {
+    readonly name: "InvalidFacetUpdateException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidFacetUpdateException, __BaseException>);
+}
+
+export interface FacetAttributeUpdate {
+    
+    Attribute?: FacetAttribute;
+    
+    Action?: UpdateActionType | string;
+}
+export declare namespace FacetAttributeUpdate {
+    
+    const filterSensitiveLog: (obj: FacetAttributeUpdate) => any;
+}
+export interface UpdateFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    AttributeUpdates?: FacetAttributeUpdate[];
+    
+    ObjectType?: ObjectType | string;
+}
+export declare namespace UpdateFacetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateFacetRequest) => any;
+}
+export interface UpdateFacetResponse {
+}
+export declare namespace UpdateFacetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateFacetResponse) => any;
+}
+export interface UpdateLinkAttributesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    TypedLinkSpecifier: TypedLinkSpecifier | undefined;
+    
+    AttributeUpdates: LinkAttributeUpdate[] | undefined;
+}
+export declare namespace UpdateLinkAttributesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateLinkAttributesRequest) => any;
+}
+export interface UpdateLinkAttributesResponse {
+}
+export declare namespace UpdateLinkAttributesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateLinkAttributesResponse) => any;
+}
+export interface UpdateObjectAttributesRequest {
+    
+    DirectoryArn: string | undefined;
+    
+    ObjectReference: ObjectReference | undefined;
+    
+    AttributeUpdates: ObjectAttributeUpdate[] | undefined;
+}
+export declare namespace UpdateObjectAttributesRequest {
+    
+    const filterSensitiveLog: (obj: UpdateObjectAttributesRequest) => any;
+}
+export interface UpdateObjectAttributesResponse {
+    
+    ObjectIdentifier?: string;
+}
+export declare namespace UpdateObjectAttributesResponse {
+    
+    const filterSensitiveLog: (obj: UpdateObjectAttributesResponse) => any;
+}
+export interface UpdateSchemaRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+}
+export declare namespace UpdateSchemaRequest {
+    
+    const filterSensitiveLog: (obj: UpdateSchemaRequest) => any;
+}
+export interface UpdateSchemaResponse {
+    
+    SchemaArn?: string;
+}
+export declare namespace UpdateSchemaResponse {
+    
+    const filterSensitiveLog: (obj: UpdateSchemaResponse) => any;
+}
+
+export interface TypedLinkFacetAttributeUpdate {
+    
+    Attribute: TypedLinkAttributeDefinition | undefined;
+    
+    Action: UpdateActionType | string | undefined;
+}
+export declare namespace TypedLinkFacetAttributeUpdate {
+    
+    const filterSensitiveLog: (obj: TypedLinkFacetAttributeUpdate) => any;
+}
+export interface UpdateTypedLinkFacetRequest {
+    
+    SchemaArn: string | undefined;
+    
+    Name: string | undefined;
+    
+    AttributeUpdates: TypedLinkFacetAttributeUpdate[] | undefined;
+    
+    IdentityAttributeOrder: string[] | undefined;
+}
+export declare namespace UpdateTypedLinkFacetRequest {
+    
+    const filterSensitiveLog: (obj: UpdateTypedLinkFacetRequest) => any;
+}
+export interface UpdateTypedLinkFacetResponse {
+}
+export declare namespace UpdateTypedLinkFacetResponse {
+    
+    const filterSensitiveLog: (obj: UpdateTypedLinkFacetResponse) => any;
+}
+
+export declare class IncompatibleSchemaException extends __BaseException {
+    readonly name: "IncompatibleSchemaException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<IncompatibleSchemaException, __BaseException>);
+}
+export interface UpgradeAppliedSchemaRequest {
+    
+    PublishedSchemaArn: string | undefined;
+    
+    DirectoryArn: string | undefined;
+    
+    DryRun?: boolean;
+}
+export declare namespace UpgradeAppliedSchemaRequest {
+    
+    const filterSensitiveLog: (obj: UpgradeAppliedSchemaRequest) => any;
+}
+export interface UpgradeAppliedSchemaResponse {
+    
+    UpgradedSchemaArn?: string;
+    
+    DirectoryArn?: string;
+}
+export declare namespace UpgradeAppliedSchemaResponse {
+    
+    const filterSensitiveLog: (obj: UpgradeAppliedSchemaResponse) => any;
+}
+export interface UpgradePublishedSchemaRequest {
+    
+    DevelopmentSchemaArn: string | undefined;
+    
+    PublishedSchemaArn: string | undefined;
+    
+    MinorVersion: string | undefined;
+    
+    DryRun?: boolean;
+}
+export declare namespace UpgradePublishedSchemaRequest {
+    
+    const filterSensitiveLog: (obj: UpgradePublishedSchemaRequest) => any;
+}
+export interface UpgradePublishedSchemaResponse {
+    
+    UpgradedSchemaArn?: string;
+}
+export declare namespace UpgradePublishedSchemaResponse {
+    
+    const filterSensitiveLog: (obj: UpgradePublishedSchemaResponse) => any;
+}