@fluidframework/map 2.0.0-dev.7.3.0.211848 → 2.0.0-dev.7.4.0.214930

package/dist/map-untrimmed.d.ts

@@ -0,0 +1,1035 @@
+/**
+ * The `map` library provides interfaces and implementing classes for map-like distributed data structures.
+ *
+ * @remarks The following distributed data structures are defined in this library:
+ *
+ * - {@link SharedMap}
+ *
+ * - {@link SharedDirectory}
+ *
+ * @packageDocumentation
+ */
+
+import { IChannelAttributes } from '@fluidframework/datastore-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IChannelServices } from '@fluidframework/datastore-definitions';
+import { IChannelStorageService } from '@fluidframework/datastore-definitions';
+import { IDisposable } from '@fluidframework/core-interfaces';
+import { IEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { IEventThisPlaceHolder } from '@fluidframework/core-interfaces';
+import { IFluidDataStoreRuntime } from '@fluidframework/datastore-definitions';
+import { IFluidHandle } from '@fluidframework/core-interfaces';
+import { IFluidSerializer } from '@fluidframework/shared-object-base';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISharedObject } from '@fluidframework/shared-object-base';
+import { ISharedObjectEvents } from '@fluidframework/shared-object-base';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryContext } from '@fluidframework/runtime-definitions';
+import { SharedObject } from '@fluidframework/shared-object-base';
+
+/**
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedDirectory}.
+ *
+ * @sealed
+ * @public
+ */
+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;
+}
+
+/**
+ * Create info for the subdirectory.
+ *
+ * @public
+ */
+export declare interface ICreateInfo {
+    /**
+     * Sequence number at which this subdirectory was created.
+     */
+    csn: number;
+    /**
+     * clientids of the clients which created this sub directory.
+     */
+    ccIds: string[];
+}
+
+/**
+ * Interface describing actions on a directory.
+ *
+ * @remarks When used as a Map, operates on its keys.
+ *
+ * @public
+ */
+export declare interface IDirectory extends Map<string, any>, IEventProvider<IDirectoryEvents>, Partial<IDisposable> {
+    /**
+     * The absolute path of the directory.
+     */
+    readonly absolutePath: string;
+    /**
+     * Retrieves the value stored at the given key from the directory.
+     * @param key - Key to retrieve from
+     * @returns The stored value, or undefined if the key is not set
+     */
+    get<T = any>(key: string): T | undefined;
+    /**
+     * Sets the value stored at key to the provided value.
+     * @param key - Key to set at
+     * @param value - Value to set
+     * @returns The IDirectory itself
+     */
+    set<T = unknown>(key: string, value: T): this;
+    /**
+     * Get the number of sub directory within the directory.
+     * @returns The number of sub directory within a directory.
+     */
+    countSubDirectory?(): number;
+    /**
+     * Creates an IDirectory child of this IDirectory, or retrieves the existing IDirectory child if one with the
+     * same name already exists.
+     * @param subdirName - Name of the new child directory to create
+     * @returns The IDirectory child that was created or retrieved
+     */
+    createSubDirectory(subdirName: string): IDirectory;
+    /**
+     * Gets an IDirectory child of this IDirectory, if it exists.
+     * @param subdirName - Name of the child directory to get
+     * @returns The requested IDirectory
+     */
+    getSubDirectory(subdirName: string): IDirectory | undefined;
+    /**
+     * Checks whether this directory has a child directory with the given name.
+     * @param subdirName - Name of the child directory to check
+     * @returns True if it exists, false otherwise
+     */
+    hasSubDirectory(subdirName: string): boolean;
+    /**
+     * Deletes an IDirectory child of this IDirectory, if it exists, along with all descendent keys and directories.
+     * @param subdirName - Name of the child directory to delete
+     * @returns True if the IDirectory existed and was deleted, false if it did not exist
+     */
+    deleteSubDirectory(subdirName: string): boolean;
+    /**
+     * Gets an iterator over the IDirectory children of this IDirectory.
+     * @returns The IDirectory iterator
+     */
+    subdirectories(): IterableIterator<[string, IDirectory]>;
+    /**
+     * Get an IDirectory within the directory, in order to use relative paths from that location.
+     * @param relativePath - Path of the IDirectory to get, relative to this IDirectory
+     * @returns The requested IDirectory
+     */
+    getWorkingDirectory(relativePath: string): IDirectory | undefined;
+}
+
+/**
+ * Operation indicating the directory should be cleared.
+ *
+ * @public
+ */
+export declare interface IDirectoryClearOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "clear";
+    /**
+     * Absolute path of the directory being cleared.
+     */
+    path: string;
+}
+
+/**
+ * Operation indicating a subdirectory should be created.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * 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}.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Operation indicating a key should be deleted from the directory.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Operation indicating a subdirectory should be deleted.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * Events emitted in response to changes to the directory data.
+ *
+ * @public
+ */
+export declare interface IDirectoryEvents extends IEvent {
+    /**
+     * Emitted when a key is set or deleted. As opposed to the
+     * {@link SharedDirectory}'s valueChanged event, this is emitted only on the {@link IDirectory} that directly
+     * contains the key.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `changed` - Information on the key that changed and its value prior to the change.
+     *
+     * - `local` - Whether the change originated from this client.
+     *
+     * - `target` - The {@link IDirectory} itself.
+     */
+    (event: "containedValueChanged", listener: (changed: IValueChanged, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when a subdirectory is created. Also emitted when a delete
+     * of a subdirectory is rolled back.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `path` - The relative path to the subdirectory that is created.
+     * It is relative from the object which raises the event.
+     *
+     * - `local` - Whether the creation originated from the this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "subDirectoryCreated", listener: (path: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when a subdirectory is deleted.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `path` - The relative path to the subdirectory that is deleted.
+     * It is relative from the object which raises the event.
+     *
+     * - `local` - Whether the delete originated from the this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "subDirectoryDeleted", listener: (path: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when this sub directory is deleted.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `target` - The {@link IDirectory} itself.
+     */
+    (event: "disposed", listener: (target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when this previously deleted sub directory is restored.
+     * This event only needs to be handled in the case of rollback. If your application does
+     * not use the local rollback feature, you can ignore this event.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `target` - The {@link IDirectory} itself.
+     */
+    (event: "undisposed", listener: (target: IEventThisPlaceHolder) => void): any;
+}
+
+/**
+ * An operation on a specific key within a directory.
+ *
+ * @public
+ */
+export declare type IDirectoryKeyOperation = IDirectorySetOperation | IDirectoryDeleteOperation;
+
+/**
+ * {@link IDirectory} storage format.
+ *
+ * @internal
+ */
+export declare interface IDirectoryNewStorageFormat {
+    /**
+     * Blob IDs representing larger directory data that was serialized.
+     */
+    blobs: string[];
+    /**
+     * Storage content representing directory data that was not serialized.
+     */
+    content: IDirectoryDataObject;
+}
+
+/**
+ * Any operation on a directory.
+ *
+ * @public
+ */
+export declare type IDirectoryOperation = IDirectoryStorageOperation | IDirectorySubDirectoryOperation;
+
+/**
+ * Operation indicating a value should be set for a key.
+ *
+ * @public
+ */
+export declare 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;
+}
+
+/**
+ * An operation on one or more of the keys within a directory.
+ *
+ * @public
+ */
+export declare type IDirectoryStorageOperation = IDirectoryKeyOperation | IDirectoryClearOperation;
+
+/**
+ * An operation on the subdirectories within a directory.
+ *
+ * @public
+ */
+export declare type IDirectorySubDirectoryOperation = IDirectoryCreateSubDirectoryOperation | IDirectoryDeleteSubDirectoryOperation;
+
+/**
+ * Type of "valueChanged" event parameter for {@link ISharedDirectory}.
+ *
+ * @public
+ */
+export declare interface IDirectoryValueChanged extends IValueChanged {
+    /**
+     * The absolute path to the IDirectory storing the key which changed.
+     */
+    path: string;
+}
+
+/**
+ * A local value to be stored in a container type Distributed Data Store (DDS).
+ *
+ * @public
+ */
+export declare interface ILocalValue {
+    /**
+     * Type indicator of the value stored within.
+     */
+    readonly type: string;
+    /**
+     * The in-memory value stored within.
+     */
+    readonly value: any;
+    /**
+     * Retrieve the serialized form of the value stored within.
+     * @param serializer - Data store runtime's serializer
+     * @param bind - Container type's handle
+     * @returns The serialized form of the contained value
+     */
+    makeSerialized(serializer: IFluidSerializer, bind: IFluidHandle): ISerializedValue;
+}
+
+/**
+ * The _ready-for-serialization_ format of values contained in DDS contents. This allows us to use
+ * {@link ISerializableValue."type"} to understand whether they're storing a Plain JavaScript object,
+ * a {@link @fluidframework/shared-object-base#SharedObject}, or a value type.
+ *
+ * @remarks
+ *
+ * Note that the in-memory equivalent of ISerializableValue is ILocalValue (similarly holding a type, but with
+ * the _in-memory representation_ of the value instead).  An ISerializableValue is what gets passed to
+ * JSON.stringify and comes out of JSON.parse. This format is used both for snapshots (loadCore/populate)
+ * and ops (set).
+ *
+ * If type is Plain, it must be a plain JS object that can survive a JSON.stringify/parse.  E.g. a URL object will
+ * just get stringified to a URL string and not rehydrate as a URL object on the other side. It may contain members
+ * that are ISerializedHandle (the serialized form of a handle).
+ *
+ * If type is a value type then it must be amongst the types registered via registerValueType or we won't know how
+ * to serialize/deserialize it (we rely on its factory via .load() and .store()).  Its value will be type-dependent.
+ * If type is Shared, then the in-memory value will just be a reference to the SharedObject.  Its value will be a
+ * channel ID.
+ *
+ * @deprecated This type is legacy and deprecated.
+ *
+ * @public
+ */
+export declare interface ISerializableValue {
+    /**
+     * A type annotation to help indicate how the value serializes.
+     */
+    type: string;
+    /**
+     * The JSONable representation of the value.
+     */
+    value: any;
+}
+
+/**
+ * Serialized {@link ISerializableValue} counterpart.
+ *
+ * @public
+ */
+export declare interface ISerializedValue {
+    /**
+     * A type annotation to help indicate how the value serializes.
+     */
+    type: string;
+    /**
+     * String representation of the value.
+     *
+     * @remarks Will be undefined if the original value was undefined.
+     */
+    value: string | undefined;
+}
+
+/**
+ * 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.
+ *
+ * @public
+ */
+export declare interface ISharedDirectory extends ISharedObject<ISharedDirectoryEvents & IDirectoryEvents>, Omit<IDirectory, "on" | "once" | "off"> {
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+    readonly [Symbol.toStringTag]: string;
+}
+
+/**
+ * Events emitted in response to changes to the directory data.
+ *
+ * @remarks
+ * These events only emit on the {@link ISharedDirectory} itself, and not on subdirectories.
+ *
+ * @public
+ */
+export declare interface ISharedDirectoryEvents extends ISharedObjectEvents {
+    /**
+     * Emitted when a key is set or deleted. This is emitted for any key in the {@link ISharedDirectory} or any
+     * subdirectory.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `changed` - Information on the key that changed, its value prior to the change, and the path to the
+     * key that changed.
+     *
+     * - `local` - Whether the change originated from this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "valueChanged", listener: (changed: IDirectoryValueChanged, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when the {@link ISharedDirectory} is cleared.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `local` - Whether the clear originated from this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "clear", listener: (local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when a subdirectory is created.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `path` - The relative path to the subdirectory that is created.
+     * It is relative from the object which raises the event.
+     *
+     * - `local` - Whether the create originated from the this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "subDirectoryCreated", listener: (path: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when a subdirectory is deleted.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `path` - The relative path to the subdirectory that is deleted.
+     * It is relative from the object which raises the event.
+     *
+     * - `local` - Whether the delete originated from the this client.
+     *
+     * - `target` - The {@link ISharedDirectory} itself.
+     */
+    (event: "subDirectoryDeleted", listener: (path: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
+}
+
+/**
+ * The SharedMap distributed data structure can be used to store key-value pairs. It provides the same API for setting
+ * and retrieving values that JavaScript developers are accustomed to with the
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map | Map} built-in object.
+ * However, the keys of a SharedMap must be strings, and the values must either be a JSON-serializable object or a
+ * {@link @fluidframework/datastore#FluidObjectHandle}.
+ *
+ * For more information, including example usages, see {@link https://fluidframework.com/docs/data-structures/map/}.
+ *
+ * @public
+ */
+export declare interface ISharedMap extends ISharedObject<ISharedMapEvents>, Map<string, any> {
+    /**
+     * Retrieves the given key from the map if it exists.
+     * @param key - Key to retrieve from
+     * @returns The stored value, or undefined if the key is not set
+     */
+    get<T = any>(key: string): T | undefined;
+    /**
+     * Sets the value stored at key to the provided value.
+     * @param key - Key to set
+     * @param value - Value to set
+     * @returns The {@link ISharedMap} itself
+     */
+    set<T = unknown>(key: string, value: T): this;
+}
+
+/**
+ * Events emitted in response to changes to the {@link ISharedMap | map} data.
+ *
+ * @public
+ */
+export declare interface ISharedMapEvents extends ISharedObjectEvents {
+    /**
+     * Emitted when a key is set or deleted.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `changed` - Information on the key that changed and its value prior to the change.
+     *
+     * - `local` - Whether the change originated from this client.
+     *
+     * - `target` - The {@link ISharedMap} itself.
+     */
+    (event: "valueChanged", listener: (changed: IValueChanged, local: boolean, target: IEventThisPlaceHolder) => void): any;
+    /**
+     * Emitted when the map is cleared.
+     *
+     * @remarks Listener parameters:
+     *
+     * - `local` - Whether the clear originated from this client.
+     *
+     * - `target` - The {@link ISharedMap} itself.
+     */
+    (event: "clear", listener: (local: boolean, target: IEventThisPlaceHolder) => void): any;
+}
+
+/**
+ * Type of "valueChanged" event parameter.
+ *
+ * @public
+ */
+export declare interface IValueChanged {
+    /**
+     * The key storing the value that changed.
+     */
+    key: string;
+    /**
+     * The value that was stored at the key prior to the change.
+     */
+    previousValue: any;
+}
+
+/**
+ * Enables a container type {@link https://fluidframework.com/docs/build/dds/ | DDS} to produce and store local
+ * values with minimal awareness of how those objects are stored, serialized, and deserialized.
+ *
+ * @public
+ */
+export declare class LocalValueMaker {
+    private readonly serializer;
+    /**
+     * Create a new LocalValueMaker.
+     * @param serializer - The serializer to serialize / parse handles.
+     */
+    constructor(serializer: IFluidSerializer);
+    /**
+     * Create a new local value from an incoming serialized value.
+     * @param serializable - The serializable value to make local
+     */
+    fromSerializable(serializable: ISerializableValue): ILocalValue;
+    /**
+     * Create a new local value containing a given plain object.
+     * @param value - The value to store
+     * @returns An ILocalValue containing the value
+     */
+    fromInMemory(value: unknown): ILocalValue;
+}
+
+/**
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedMap}.
+ *
+ * @sealed
+ * @public
+ */
+export declare class MapFactory implements IChannelFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
+     */
+    static readonly Type = "https://graph.microsoft.com/types/map";
+    /**
+     * {@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<ISharedMap>;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+     */
+    create(runtime: IFluidDataStoreRuntime, id: string): ISharedMap;
+}
+
+/**
+ * {@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
+ * @public
+ */
+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;
+    /**
+     * @internal
+     */
+    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}
+     * @internal
+     */
+    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.
+     * @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: 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: 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}
+     * @internal
+     */
+    protected applyStashedOp(op: unknown): unknown;
+    private serializeDirectory;
+}
+
+/**
+ * {@inheritDoc ISharedMap}
+ *
+ * @public
+ */
+export declare class SharedMap extends SharedObject<ISharedMapEvents> implements ISharedMap {
+    /**
+     * Create a new shared map.
+     * @param runtime - The data store runtime that the new shared map belongs to.
+     * @param id - Optional name of the shared map.
+     * @returns Newly created shared map.
+     *
+     * @example
+     * To create a `SharedMap`, call the static create method:
+     *
+     * ```typescript
+     * const myMap = SharedMap.create(this.runtime, id);
+     * ```
+     */
+    static create(runtime: IFluidDataStoreRuntime, id?: string): SharedMap;
+    /**
+     * Get a factory for SharedMap to register with the data store.
+     * @returns A factory that creates SharedMaps and loads them from storage.
+     */
+    static getFactory(): IChannelFactory;
+    /**
+     * String representation for the class.
+     */
+    readonly [Symbol.toStringTag]: string;
+    /**
+     * MapKernel which manages actual map operations.
+     */
+    private readonly kernel;
+    /**
+     * Do not call the constructor. Instead, you should use the {@link SharedMap.create | create method}.
+     *
+     * @param id - String identifier.
+     * @param runtime - Data store runtime.
+     * @param attributes - The attributes for the map.
+     */
+    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
+    /**
+     * Get an iterator over the keys in this map.
+     * @returns The iterator
+     */
+    keys(): IterableIterator<string>;
+    /**
+     * Get an iterator over the entries in this map.
+     * @returns The iterator
+     */
+    entries(): IterableIterator<[string, any]>;
+    /**
+     * Get an iterator over the values in this map.
+     * @returns The iterator
+     */
+    values(): IterableIterator<any>;
+    /**
+     * Get an iterator over the entries in this map.
+     * @returns The iterator
+     */
+    [Symbol.iterator](): IterableIterator<[string, any]>;
+    /**
+     * The number of key/value pairs stored in the map.
+     */
+    get size(): number;
+    /**
+     * Executes the given callback on each entry in the map.
+     * @param callbackFn - Callback function
+     */
+    forEach(callbackFn: (value: any, key: string, map: Map<string, any>) => void): void;
+    /**
+     * {@inheritDoc ISharedMap.get}
+     */
+    get<T = any>(key: string): T | undefined;
+    /**
+     * Check if a key exists in the map.
+     * @param key - The key to check
+     * @returns True if the key exists, false otherwise
+     */
+    has(key: string): boolean;
+    /**
+     * {@inheritDoc ISharedMap.set}
+     */
+    set(key: string, value: unknown): this;
+    /**
+     * Delete a key from the map.
+     * @param key - Key to delete
+     * @returns True if the key existed and was deleted, false if it did not exist
+     */
+    delete(key: string): boolean;
+    /**
+     * Clear all data from the map.
+     */
+    clear(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
+     * @internal
+     */
+    protected summarizeCore(serializer: IFluidSerializer, telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     * @internal
+     */
+    protected loadCore(storage: IChannelStorageService): Promise<void>;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
+     * @internal
+     */
+    protected onDisconnect(): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
+     * @internal
+     */
+    protected reSubmitCore(content: unknown, localOpMetadata: unknown): void;
+    /**
+     * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
+     * @internal
+     */
+    protected applyStashedOp(content: unknown): unknown;
+    /**
+     * {@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: unknown, localOpMetadata: unknown): void;
+}
+
+export { }