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

package/lib/directory.d.mts

@@ -0,0 +1,902 @@
+/*!
+ * 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 { RedBlackTree } from "@fluidframework/merge-tree";
+import { IDirectory, IDirectoryEvents, ISerializableValue, ISerializedValue, ISharedDirectory, ISharedDirectoryEvents } from "./interfaces.mjs";
+import { ILocalValue, LocalValueMaker } from "./localValues.mjs";
+/**
+ * Operation indicating a value should be set for a key.
+ * @alpha
+ */
+export interface IDirectorySetOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "set";
+    /**
+     * Directory key being modified.
+     */
+    key: string;
+    /**
+     * Absolute path of the directory where the modified key is located.
+     */
+    path: string;
+    /**
+     * Value to be set on the key.
+     */
+    value: ISerializableValue;
+}
+/**
+ * Operation indicating a key should be deleted from the directory.
+ * @alpha
+ */
+export interface IDirectoryDeleteOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "delete";
+    /**
+     * Directory key being modified.
+     */
+    key: string;
+    /**
+     * Absolute path of the directory where the modified key is located.
+     */
+    path: string;
+}
+/**
+ * An operation on a specific key within a directory.
+ * @alpha
+ */
+export type IDirectoryKeyOperation = IDirectorySetOperation | IDirectoryDeleteOperation;
+/**
+ * Operation indicating the directory should be cleared.
+ * @alpha
+ */
+export interface IDirectoryClearOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "clear";
+    /**
+     * Absolute path of the directory being cleared.
+     */
+    path: string;
+}
+/**
+ * An operation on one or more of the keys within a directory.
+ * @alpha
+ */
+export type IDirectoryStorageOperation = IDirectoryKeyOperation | IDirectoryClearOperation;
+/**
+ * Operation indicating a subdirectory should be created.
+ * @alpha
+ */
+export interface IDirectoryCreateSubDirectoryOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "createSubDirectory";
+    /**
+     * Absolute path of the directory that will contain the new subdirectory.
+     */
+    path: string;
+    /**
+     * Name of the new subdirectory.
+     */
+    subdirName: string;
+}
+/**
+ * Operation indicating a subdirectory should be deleted.
+ * @alpha
+ */
+export interface IDirectoryDeleteSubDirectoryOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "deleteSubDirectory";
+    /**
+     * Absolute path of the directory that contains the directory to be deleted.
+     */
+    path: string;
+    /**
+     * Name of the subdirectory to be deleted.
+     */
+    subdirName: string;
+}
+/**
+ * An operation on the subdirectories within a directory.
+ * @alpha
+ */
+export type IDirectorySubDirectoryOperation = IDirectoryCreateSubDirectoryOperation | IDirectoryDeleteSubDirectoryOperation;
+/**
+ * Any operation on a directory.
+ * @alpha
+ */
+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.
+ *
+ * @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;
+}
+/**
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedDirectory}.
+ *
+ * @sealed
+ * @alpha
+ */
+export declare class DirectoryFactory implements IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
+     */
+    static readonly Type = "https://graph.microsoft.com/types/directory";
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.attributes}
+     */
+    static readonly Attributes: IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
+     */
+    get type(): string;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.attributes}
+     */
+    get attributes(): IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+     */
+    load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<ISharedDirectory>;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+     */
+    create(runtime: IFluidDataStoreRuntime, id: string): ISharedDirectory;
+}
+/**
+ * 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");
+ * mySubDir.get("foo"); // returns val1
+ * ```
+ *
+ * @sealed
+ * @alpha
+ */
+export declare class SharedDirectory extends SharedObject<ISharedDirectoryEvents> implements ISharedDirectory {
+    /**
+     * Create a new shared directory
+     *
+     * @param runtime - Data store runtime the new shared directory belongs to
+     * @param id - Optional name of the shared directory
+     * @returns Newly create shared directory (but not attached yet)
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedDirectory;
+    /**
+     * Get a factory for SharedDirectory to register with the data store.
+     *
+     * @returns A factory that creates and load SharedDirectory
+     */
+    static getFactory(): IChannelFactory;
+    /**
+     * String representation for the class.
+     */
+    [Symbol.toStringTag]: string;
+    /**
+     * {@inheritDoc IDirectory.absolutePath}
+     */
+    get absolutePath(): string;
+    /***/
+    readonly localValueMaker: LocalValueMaker;
+    /**
+     * Root of the SharedDirectory, most operations on the SharedDirectory itself act on the root.
+     */
+    private readonly root;
+    /**
+     * Mapping of op types to message handlers.
+     */
+    private readonly messageHandlers;
+    /**
+     * Constructs a new shared directory. If the object is non-local an id and service interfaces will
+     * be provided.
+     * @param id - String identifier for the SharedDirectory
+     * @param runtime - Data store runtime
+     * @param type - Type identifier
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * {@inheritDoc IDirectory.get}
+     */
+    get<T = any>(key: string): T | undefined;
+    /**
+     * {@inheritDoc IDirectory.set}
+     */
+    set<T = unknown>(key: string, value: T): this;
+    dispose(error?: Error): void;
+    get disposed(): 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;
+    /**
+     * 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;
+    /**
+     * The number of entries under this IDirectory.
+     */
+    get size(): number;
+    /**
+     * Issue a callback on each entry under this IDirectory.
+     * @param callback - Callback to issue
+     */
+    forEach(callback: (value: any, key: string, map: Map<string, any>) => void): void;
+    /**
+     * Get an iterator over the entries under this IDirectory.
+     * @returns The iterator
+     */
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+    /**
+     * Get an iterator over the entries under this IDirectory.
+     * @returns The iterator
+     */
+    entries(): IterableIterator<[string, any]>;
+    /**
+     * {@inheritDoc IDirectory.countSubDirectory}
+     */
+    countSubDirectory(): number;
+    /**
+     * 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<any>;
+    /**
+     * {@inheritDoc IDirectory.createSubDirectory}
+     */
+    createSubDirectory(subdirName: string): IDirectory;
+    /**
+     * {@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;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+     */
+    protected summarizeCore(serializer: IFluidSerializer, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * Submits an operation
+     * @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.
+     */
+    submitDirectoryMessage(op: IDirectoryOperation, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+     */
+    protected onDisconnect(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
+     */
+    protected reSubmitCore(content: unknown, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * Populate the directory with the given directory data.
+     * @param data - A JSON string containing serialized directory data
+     */
+    protected populate(data: IDirectoryDataObject): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.processCore}
+     */
+    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
+     */
+    protected rollback(content: unknown, localOpMetadata: unknown): void;
+    /**
+     * Converts the given relative path to absolute against the root.
+     * @param relativePath - The path to convert
+     */
+    private makeAbsolute;
+    /**
+     * The remote ISerializableValue we're receiving (either as a result of a snapshot load or an incoming set op)
+     * will have the information we need to create a real object, but will not be the real object yet.  For example,
+     * we might know it's a map and the ID but not have the actual map or its data yet.  makeLocal's job
+     * is to convert that information into a real object for local usage.
+     * @param key - Key of element being converted
+     * @param absolutePath - Path of element being converted
+     * @param serializable - The remote information that we can convert into a real object
+     * @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;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     */
+    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.mts.map