@fluidframework/map 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.225277

package/dist/directory.d.ts

@@ -2,14 +2,17 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { IChannelAttributes, IFluidDataStoreRuntime, IChannelStorageService, IChannelServices, IChannelFactory } from "@fluidframework/datastore-definitions";
 import { ISummaryTreeWithStats, ITelemetryContext } from "@fluidframework/runtime-definitions";
 import { IFluidSerializer, SharedObject } from "@fluidframework/shared-object-base";
-import { IDirectory, ISerializableValue, ISharedDirectory, ISharedDirectoryEvents } from "./interfaces";
-import { LocalValueMaker } from "./localValues";
+import { RedBlackTree } from "@fluidframework/merge-tree";
+import { IDirectory, IDirectoryEvents, ISerializableValue, ISerializedValue, ISharedDirectory, ISharedDirectoryEvents } from "./interfaces";
+import { ILocalValue, LocalValueMaker } from "./localValues";
 /**
  * Operation indicating a value should be set for a key.
+ * @alpha
  */
 export interface IDirectorySetOperation {
     /**
@@ -31,6 +34,7 @@ export interface IDirectorySetOperation {
 }
 /**
  * Operation indicating a key should be deleted from the directory.
+ * @alpha
  */
 export interface IDirectoryDeleteOperation {
     /**
@@ -47,11 +51,13 @@ export interface IDirectoryDeleteOperation {
     path: string;
 }
 /**
- * An operation on a specific key within a directory
+ * An operation on a specific key within a directory.
+ * @alpha
  */
-export declare type IDirectoryKeyOperation = IDirectorySetOperation | IDirectoryDeleteOperation;
+export type IDirectoryKeyOperation = IDirectorySetOperation | IDirectoryDeleteOperation;
 /**
  * Operation indicating the directory should be cleared.
+ * @alpha
  */
 export interface IDirectoryClearOperation {
     /**
@@ -64,11 +70,13 @@ export interface IDirectoryClearOperation {
     path: string;
 }
 /**
- * An operation on one or more of the keys within a directory
+ * An operation on one or more of the keys within a directory.
+ * @alpha
  */
-export declare type IDirectoryStorageOperation = IDirectoryKeyOperation | IDirectoryClearOperation;
+export type IDirectoryStorageOperation = IDirectoryKeyOperation | IDirectoryClearOperation;
 /**
  * Operation indicating a subdirectory should be created.
+ * @alpha
  */
 export interface IDirectoryCreateSubDirectoryOperation {
     /**
@@ -86,6 +94,7 @@ export interface IDirectoryCreateSubDirectoryOperation {
 }
 /**
  * Operation indicating a subdirectory should be deleted.
+ * @alpha
  */
 export interface IDirectoryDeleteSubDirectoryOperation {
     /**
@@ -102,35 +111,82 @@ export interface IDirectoryDeleteSubDirectoryOperation {
     subdirName: string;
 }
 /**
- * An operation on the subdirectories within a directory
+ * An operation on the subdirectories within a directory.
+ * @alpha
  */
-export declare type IDirectorySubDirectoryOperation = IDirectoryCreateSubDirectoryOperation | IDirectoryDeleteSubDirectoryOperation;
+export type IDirectorySubDirectoryOperation = IDirectoryCreateSubDirectoryOperation | IDirectoryDeleteSubDirectoryOperation;
 /**
- * Any operation on a directory
+ * Any operation on a directory.
+ * @alpha
  */
-export declare type IDirectoryOperation = IDirectoryStorageOperation | IDirectorySubDirectoryOperation;
+export type IDirectoryOperation = IDirectoryStorageOperation | IDirectorySubDirectoryOperation;
+/**
+ * Create info for the subdirectory.
+ * @alpha
+ */
+export interface ICreateInfo {
+    /**
+     * Sequence number at which this subdirectory was created.
+     */
+    csn: number;
+    /**
+     * clientids of the clients which created this sub directory.
+     */
+    ccIds: string[];
+}
 /**
  * Defines the in-memory object structure to be used for the conversion to/from serialized.
- * @privateRemarks
- * Directly used in JSON.stringify, direct result from JSON.parse.
+ *
+ * @remarks Directly used in
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+ * | JSON.stringify}, direct result from
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse | JSON.parse}.
+ * @alpha
  */
 export interface IDirectoryDataObject {
+    /**
+     * Key/value date set by the user.
+     */
     storage?: {
         [key: string]: ISerializableValue;
     };
+    /**
+     * Recursive sub-directories {@link IDirectoryDataObject | objects}.
+     */
     subdirectories?: {
         [subdirName: string]: IDirectoryDataObject;
     };
+    /**
+     * Create info for the sub directory. Since directories with same name can get deleted/created by multiple clients
+     * asynchronously, this info helps us to determine whether the ops where for the current instance of sub directory
+     * or not and whether to process them or not based on that. Summaries which were not produced which this change
+     * will not have this info and in that case we can still run in eventual consistency issues but that is no worse
+     * than the state before this change.
+     */
+    ci?: ICreateInfo;
 }
+/**
+ * {@link IDirectory} storage format.
+ *
+ * @internal
+ */
 export interface IDirectoryNewStorageFormat {
+    /**
+     * Blob IDs representing larger directory data that was serialized.
+     */
     blobs: string[];
+    /**
+     * Storage content representing directory data that was not serialized.
+     */
     content: IDirectoryDataObject;
 }
 /**
- * The factory that defines the directory.
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedDirectory}.
+ *
  * @sealed
+ * @alpha
  */
-export declare class DirectoryFactory {
+export declare class DirectoryFactory implements IChannelFactory {
     /**
      * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
      */
@@ -157,11 +213,38 @@ export declare class DirectoryFactory {
     create(runtime: IFluidDataStoreRuntime, id: string): ISharedDirectory;
 }
 /**
- * SharedDirectory provides a hierarchical organization of map-like data structures as SubDirectories.
- * The values stored within can be accessed like a map, and the hierarchy can be navigated using path syntax.
- * SubDirectories can be retrieved for use as working directories.
+ * The combination of sequence numebr and client sequence number of a subdirectory
+ */
+interface SequenceData {
+    seq: number;
+    clientSeq?: number;
+}
+/**
+ * A utility class for tracking associations between keys and their creation indices.
+ * This is relevant to support map iteration in insertion order, see
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Iterator/%40%40iterator
+ *
+ * TODO: It can be combined with the creation tracker utilized in SharedMap
+ */
+declare class DirectoryCreationTracker {
+    readonly indexToKey: RedBlackTree<SequenceData, string>;
+    readonly keyToIndex: Map<string, SequenceData>;
+    constructor();
+    set(key: string, seqData: SequenceData): void;
+    has(keyOrSeqData: string | SequenceData): boolean;
+    delete(keyOrSeqData: string | SequenceData): void;
+    /**
+     * Retrieves all subdirectories with creation order that satisfy an optional constraint function.
+     * @param constraint - An optional constraint function that filters keys.
+     * @returns An array of keys that satisfy the constraint (or all keys if no constraint is provided).
+     */
+    keys(constraint?: (key: string) => boolean): string[];
+}
+/**
+ * {@inheritDoc ISharedDirectory}
  *
  * @example
+ *
  * ```typescript
  * mySharedDirectory.createSubDirectory("a").createSubDirectory("b").createSubDirectory("c").set("foo", val1);
  * const mySubDir = mySharedDirectory.getWorkingDirectory("/a/b/c");
@@ -169,6 +252,7 @@ export declare class DirectoryFactory {
  * ```
  *
  * @sealed
+ * @alpha
  */
 export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents> implements ISharedDirectory {
     /**
@@ -193,9 +277,7 @@ export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents
      * {@inheritDoc IDirectory.absolutePath}
      */
     get absolutePath(): string;
-    /**
-     * @internal
-     */
+    /***/
     readonly localValueMaker: LocalValueMaker;
     /**
      * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
@@ -220,7 +302,7 @@ export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents
     /**
      * {@inheritDoc IDirectory.set}
      */
-    set<T = any>(key: string, value: T): this;
+    set<T = unknown>(key: string, value: T): this;
     dispose(error?: Error): void;
     get disposed(): boolean;
     /**
@@ -298,7 +380,6 @@ export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents
     getWorkingDirectory(relativePath: string): IDirectory | undefined;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
-     * @internal
      */
     protected summarizeCore(serializer: IFluidSerializer, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
     /**
@@ -306,40 +387,33 @@ export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents
      * @param op - Op to submit
      * @param localOpMetadata - The local metadata associated with the op. We send a unique id that is used to track
      * this op while it has not been ack'd. This will be sent when we receive this op back from the server.
-     * @internal
      */
     submitDirectoryMessage(op: IDirectoryOperation, localOpMetadata: unknown): void;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
-     * @internal
      */
     protected onDisconnect(): void;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
-     * @internal
      */
-    protected reSubmitCore(content: any, localOpMetadata: unknown): void;
+    protected reSubmitCore(content: unknown, localOpMetadata: unknown): void;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     * @internal
      */
     protected loadCore(storage: IChannelStorageService): Promise<void>;
     /**
      * Populate the directory with the given directory data.
      * @param data - A JSON string containing serialized directory data
-     * @internal
      */
     protected populate(data: IDirectoryDataObject): void;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
-     * @internal
      */
     protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
-     * @internal
-    */
-    protected rollback(content: any, localOpMetadata: unknown): void;
+     */
+    protected rollback(content: unknown, localOpMetadata: unknown): void;
     /**
      * Converts the given relative path to absolute against the root.
      * @param relativePath - The path to convert
@@ -356,14 +430,473 @@ export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents
      * @returns The local value that was produced
      */
     private makeLocal;
+    /**
+     * This checks if there is pending delete op for local delete for a any subdir in the relative path.
+     * @param relativePath - path of sub directory.
+     * @returns `true` if there is pending delete, `false` otherwise.
+     */
+    private isSubDirectoryDeletePending;
     /**
      * Set the message handlers for the directory.
      */
     private setMessageHandlers;
     /**
-     * @internal
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
      */
-    protected applyStashedOp(): void;
+    protected applyStashedOp(op: unknown): unknown;
     private serializeDirectory;
 }
+interface IKeyEditLocalOpMetadata {
+    type: "edit";
+    pendingMessageId: number;
+    previousValue: ILocalValue | undefined;
+}
+interface IClearLocalOpMetadata {
+    type: "clear";
+    pendingMessageId: number;
+    previousStorage: Map<string, ILocalValue>;
+}
+interface ICreateSubDirLocalOpMetadata {
+    type: "createSubDir";
+}
+interface IDeleteSubDirLocalOpMetadata {
+    type: "deleteSubDir";
+    subDirectory: SubDirectory | undefined;
+}
+type SubDirLocalOpMetadata = ICreateSubDirLocalOpMetadata | IDeleteSubDirLocalOpMetadata;
+export type DirectoryLocalOpMetadata = IClearLocalOpMetadata | IKeyEditLocalOpMetadata | SubDirLocalOpMetadata;
+/**
+ * Node of the directory tree.
+ * @sealed
+ */
+declare class SubDirectory extends TypedEventEmitter<IDirectoryEvents> implements IDirectory {
+    private readonly seqData;
+    private readonly clientIds;
+    private readonly directory;
+    private readonly runtime;
+    private readonly serializer;
+    readonly absolutePath: string;
+    /**
+     * Tells if the sub directory is deleted or not.
+     */
+    private _deleted;
+    /**
+     * String representation for the class.
+     */
+    [Symbol.toStringTag]: string;
+    /**
+     * The in-memory data the directory is storing.
+     */
+    private readonly _storage;
+    /**
+     * The subdirectories the directory is holding.
+     */
+    private readonly _subdirectories;
+    /**
+     * Keys that have been modified locally but not yet ack'd from the server. This is for operations on keys like
+     * set/delete operations on keys. The value of this map is list of pendingMessageIds at which that key
+     * was modified. We don't store the type of ops, and behaviour of key ops are different from behaviour of sub
+     * directory ops, so we have separate map from subDirectories tracker.
+     */
+    private readonly pendingKeys;
+    /**
+     * Subdirectories that have been deleted locally but not yet ack'd from the server. This maintains the record
+     * of delete op that are pending or yet to be acked from server. This is maintained just to track the locally
+     * deleted sub directory.
+     */
+    private readonly pendingDeleteSubDirectoriesTracker;
+    /**
+     * Subdirectories that have been created locally but not yet ack'd from the server. This maintains the record
+     * of create op that are pending or yet to be acked from server. This is maintained just to track the locally
+     * created sub directory.
+     */
+    private readonly pendingCreateSubDirectoriesTracker;
+    /**
+     * This is used to assign a unique id to every outgoing operation and helps in tracking unack'd ops.
+     */
+    private pendingMessageId;
+    /**
+     * The pending ids of any clears that have been performed locally but not yet ack'd from the server
+     */
+    private readonly pendingClearMessageIds;
+    /**
+     * Assigns a unique ID to each subdirectory created locally but pending for acknowledgement, facilitating the tracking
+     * of the creation order.
+     */
+    localCreationSeq: number;
+    /**
+     * Maintains a bidirectional association between ack'd subdirectories and their seqData.
+     * This helps to ensure iteration order which is consistent with the JS map spec.
+     */
+    readonly ackedCreationSeqTracker: DirectoryCreationTracker;
+    /**
+     * Similar to {@link ackedCreationSeqTracker}, but for local (unacked) entries.
+     */
+    readonly localCreationSeqTracker: DirectoryCreationTracker;
+    /**
+     * Constructor.
+     * @param sequenceNumber - Message seq number at which this was created.
+     * @param clientIds - Ids of client which created this directory.
+     * @param directory - Reference back to the SharedDirectory to perform operations
+     * @param runtime - The data store runtime this directory is associated with
+     * @param serializer - The serializer to serialize / parse handles
+     * @param absolutePath - The absolute path of this IDirectory
+     */
+    constructor(seqData: SequenceData, clientIds: Set<string>, directory: SharedDirectory, runtime: IFluidDataStoreRuntime, serializer: IFluidSerializer, absolutePath: string);
+    dispose(error?: Error): void;
+    /**
+     * Unmark the deleted property only when rolling back delete.
+     */
+    private undispose;
+    get disposed(): boolean;
+    private throwIfDisposed;
+    /**
+     * Checks whether the given key exists in this IDirectory.
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: string): boolean;
+    /**
+     * {@inheritDoc IDirectory.get}
+     */
+    get<T = unknown>(key: string): T | undefined;
+    /**
+     * {@inheritDoc IDirectory.set}
+     */
+    set<T = unknown>(key: string, value: T): this;
+    /**
+     * {@inheritDoc IDirectory.countSubDirectory}
+     */
+    countSubDirectory(): number;
+    /**
+     * {@inheritDoc IDirectory.createSubDirectory}
+     */
+    createSubDirectory(subdirName: string): IDirectory;
+    /**
+     * @returns The Sequence Data which should be used for local changes.
+     * @remarks While detached, 0 is used rather than -1 to represent a change which should be universally known (as opposed to known
+     * only by the local client). This ensures that if the directory is later attached, none of its data needs to be updated (the values
+     * last set while detached will now be known to any new client, until they are changed).
+     *
+     * The client sequence number is incremented by 1 for maintaining the internal order of locally created subdirectories
+     * TODO: Convert these conventions to named constants. The semantics used here match those for merge-tree.
+     */
+    private getLocalSeq;
+    /**
+     * {@inheritDoc IDirectory.getSubDirectory}
+     */
+    getSubDirectory(subdirName: string): IDirectory | undefined;
+    /**
+     * {@inheritDoc IDirectory.hasSubDirectory}
+     */
+    hasSubDirectory(subdirName: string): boolean;
+    /**
+     * {@inheritDoc IDirectory.deleteSubDirectory}
+     */
+    deleteSubDirectory(subdirName: string): boolean;
+    /**
+     * {@inheritDoc IDirectory.subdirectories}
+     */
+    subdirectories(): IterableIterator<[string, IDirectory]>;
+    /**
+     * {@inheritDoc IDirectory.getWorkingDirectory}
+     */
+    getWorkingDirectory(relativePath: string): IDirectory | undefined;
+    /**
+     * This checks if there is pending delete op for local delete for a given child subdirectory.
+     * @param subDirName - directory name.
+     * @returns true if there is pending delete.
+     */
+    isSubDirectoryDeletePending(subDirName: string): boolean;
+    /**
+     * Deletes the given key from within this IDirectory.
+     * @param key - The key to delete
+     * @returns True if the key existed and was deleted, false if it did not exist
+     */
+    delete(key: string): boolean;
+    /**
+     * Deletes all keys from within this IDirectory.
+     */
+    clear(): void;
+    /**
+     * Issue a callback on each entry under this IDirectory.
+     * @param callback - Callback to issue
+     */
+    forEach(callback: (value: unknown, key: string, map: Map<string, unknown>) => void): void;
+    /**
+     * The number of entries under this IDirectory.
+     */
+    get size(): number;
+    /**
+     * Get an iterator over the entries under this IDirectory.
+     * @returns The iterator
+     */
+    entries(): IterableIterator<[string, unknown]>;
+    /**
+     * Get an iterator over the keys under this IDirectory.
+     * @returns The iterator
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Get an iterator over the values under this IDirectory.
+     * @returns The iterator
+     */
+    values(): IterableIterator<unknown>;
+    /**
+     * Get an iterator over the entries under this IDirectory.
+     * @returns The iterator
+     */
+    [Symbol.iterator](): IterableIterator<[string, unknown]>;
+    /**
+     * Process a clear operation.
+     * @param msg - The message from the server to apply.
+     * @param op - The op to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @internal
+     */
+    processClearMessage(msg: ISequencedDocumentMessage, op: IDirectoryClearOperation, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Apply clear operation locally and generate metadata
+     * @param op - Op to apply
+     * @returns metadata generated for stahed op
+     */
+    applyStashedClearMessage(op: IDirectoryClearOperation): IClearLocalOpMetadata;
+    /**
+     * Process a delete operation.
+     * @param msg - The message from the server to apply.
+     * @param op - The op to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @internal
+     */
+    processDeleteMessage(msg: ISequencedDocumentMessage, op: IDirectoryDeleteOperation, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Apply delete operation locally and generate metadata
+     * @param op - Op to apply
+     * @returns metadata generated for stahed op
+     */
+    applyStashedDeleteMessage(op: IDirectoryDeleteOperation): IKeyEditLocalOpMetadata;
+    /**
+     * Process a set operation.
+     * @param msg - The message from the server to apply.
+     * @param op - The op to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @internal
+     */
+    processSetMessage(msg: ISequencedDocumentMessage, op: IDirectorySetOperation, context: ILocalValue | undefined, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Apply set operation locally and generate metadata
+     * @param op - Op to apply
+     * @returns metadata generated for stahed op
+     */
+    applyStashedSetMessage(op: IDirectorySetOperation, context: ILocalValue): IKeyEditLocalOpMetadata;
+    /**
+     * Process a create subdirectory operation.
+     * @param msg - The message from the server to apply.
+     * @param op - The op to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @internal
+     */
+    processCreateSubDirectoryMessage(msg: ISequencedDocumentMessage, op: IDirectoryCreateSubDirectoryOperation, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Apply createSubDirectory operation locally and generate metadata
+     * @param op - Op to apply
+     * @returns metadata generated for stahed op
+     */
+    applyStashedCreateSubDirMessage(op: IDirectoryCreateSubDirectoryOperation): ICreateSubDirLocalOpMetadata;
+    /**
+     * Process a delete subdirectory operation.
+     * @param msg - The message from the server to apply.
+     * @param op - The op to process
+     * @param local - Whether the message originated from the local client
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @internal
+     */
+    processDeleteSubDirectoryMessage(msg: ISequencedDocumentMessage, op: IDirectoryDeleteSubDirectoryOperation, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Apply deleteSubDirectory operation locally and generate metadata
+     * @param op - Op to apply
+     * @returns metadata generated for stahed op
+     */
+    applyStashedDeleteSubDirMessage(op: IDirectoryDeleteSubDirectoryOperation): IDeleteSubDirLocalOpMetadata;
+    /**
+     * Submit a clear operation.
+     * @param op - The operation
+     */
+    private submitClearMessage;
+    /**
+     * Resubmit a clear operation.
+     * @param op - The operation
+     * @internal
+     */
+    resubmitClearMessage(op: IDirectoryClearOperation, localOpMetadata: unknown): void;
+    /**
+     * Get a new pending message id for the op and cache it to track the pending op
+     */
+    private getKeyMessageId;
+    /**
+     * Submit a key operation.
+     * @param op - The operation
+     * @param previousValue - The value of the key before this op
+     */
+    private submitKeyMessage;
+    /**
+     * Submit a key message to remote clients based on a previous submit.
+     * @param op - The map key message
+     * @param localOpMetadata - Metadata from the previous submit
+     * @internal
+     */
+    resubmitKeyMessage(op: IDirectoryKeyOperation, localOpMetadata: unknown): void;
+    private incrementPendingSubDirCount;
+    private decrementPendingSubDirCount;
+    /**
+     * Update the count for pending create/delete of the sub directory so that it can be validated on receiving op
+     * or while resubmitting the op.
+     */
+    private updatePendingSubDirMessageCount;
+    /**
+     * Submit a create subdirectory operation.
+     * @param op - The operation
+     */
+    private submitCreateSubDirectoryMessage;
+    /**
+     * Submit a delete subdirectory operation.
+     * @param op - The operation
+     * @param subDir - Any subdirectory deleted by the op
+     */
+    private submitDeleteSubDirectoryMessage;
+    /**
+     * Submit a subdirectory operation again
+     * @param op - The operation
+     * @param localOpMetadata - metadata submitted with the op originally
+     * @internal
+     */
+    resubmitSubDirectoryMessage(op: IDirectorySubDirectoryOperation, localOpMetadata: unknown): void;
+    /**
+     * Get the storage of this subdirectory in a serializable format, to be used in snapshotting.
+     * @param serializer - The serializer to use to serialize handles in its values.
+     * @returns The JSONable string representing the storage of this subdirectory
+     * @internal
+     */
+    getSerializedStorage(serializer: IFluidSerializer): Generator<[string, ISerializedValue], void>;
+    getSerializableCreateInfo(): ICreateInfo;
+    /**
+     * Populate a key value in this subdirectory's storage, to be used when loading from snapshot.
+     * @param key - The key to populate
+     * @param localValue - The local value to populate into it
+     * @internal
+     */
+    populateStorage(key: string, localValue: ILocalValue): void;
+    /**
+     * Populate a subdirectory into this subdirectory, to be used when loading from snapshot.
+     * @param subdirName - The name of the subdirectory to add
+     * @param newSubDir - The new subdirectory to add
+     * @internal
+     */
+    populateSubDirectory(subdirName: string, newSubDir: SubDirectory): void;
+    /**
+     * Retrieve the local value at the given key.  This is used to get value type information stashed on the local
+     * value so op handlers can be retrieved
+     * @param key - The key to retrieve from
+     * @returns The local value
+     * @internal
+     */
+    getLocalValue<T extends ILocalValue = ILocalValue>(key: string): T;
+    /**
+     * Remove the pendingMessageId from the map tracking it on rollback
+     * @param map - map tracking the pending messages
+     * @param key - key of the edit in the op
+     */
+    private rollbackPendingMessageId;
+    /**
+     * Rollback a local op
+     * @param op - The operation to rollback
+     * @param localOpMetadata - The local metadata associated with the op.
+     */
+    rollback(op: any, localOpMetadata: unknown): void;
+    /**
+     * Converts the given relative path into an absolute path.
+     * @param path - Relative path to convert
+     * @returns The equivalent absolute path
+     */
+    private makeAbsolute;
+    /**
+     * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
+     * not process the incoming operation.
+     * @param op - Operation to check
+     * @param local - Whether the operation originated from the local client
+     * @param localOpMetadata - For local client ops, this is the metadata that was submitted with the op.
+     * For ops from a remote client, this will be undefined.
+     * @returns True if the operation should be processed, false otherwise
+     */
+    private needProcessStorageOperation;
+    /**
+     * This return true if the message is for the current instance of this sub directory. As the sub directory
+     * can be deleted and created again, then this finds if the message is for current instance of directory or not.
+     * @param msg - message for the directory
+     */
+    private isMessageForCurrentInstanceOfSubDirectory;
+    /**
+     * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
+     * not process the incoming operation.
+     * @param op - Operation to check
+     * @param local - Whether the message originated from the local client
+     * @param message - The message
+     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
+     * For messages from a remote client, this will be undefined.
+     * @returns True if the operation should be processed, false otherwise
+     */
+    private needProcessSubDirectoryOperation;
+    /**
+     * Clear all keys in memory in response to a remote clear, but retain keys we have modified but not yet been ack'd.
+     */
+    private clearExceptPendingKeys;
+    /**
+     * Clear implementation used for both locally sourced clears as well as incoming remote clears.
+     * @param local - Whether the message originated from the local client
+     */
+    private clearCore;
+    /**
+     * Delete implementation used for both locally sourced deletes as well as incoming remote deletes.
+     * @param key - The key being deleted
+     * @param local - Whether the message originated from the local client
+     * @returns Previous local value of the key if it existed, undefined if it did not exist
+     */
+    private deleteCore;
+    /**
+     * Set implementation used for both locally sourced sets as well as incoming remote sets.
+     * @param key - The key being set
+     * @param value - The value being set
+     * @param local - Whether the message originated from the local client
+     * @returns Previous local value of the key, if any
+     */
+    private setCore;
+    /**
+     * Create subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
+     * @param subdirName - The name of the subdirectory being created
+     * @param local - Whether the message originated from the local client
+     * @param seqData - Sequence number and client sequence number at which this directory is created
+     * @param clientId - Id of client which created this directory.
+     * @returns True if is newly created, false if it already existed.
+     */
+    private createSubDirectoryCore;
+    private registerEventsOnSubDirectory;
+    /**
+     * Delete subdirectory implementation used for both locally sourced creation as well as incoming remote creation.
+     * @param subdirName - The name of the subdirectory being deleted
+     * @param local - Whether the message originated from the local client
+     */
+    private deleteSubDirectoryCore;
+    private disposeSubDirectoryTree;
+    private undeleteSubDirectoryTree;
+}
+export {};
 //# sourceMappingURL=directory.d.ts.map