@fluidframework/runtime-definitions 2.0.0-internal.7.2.2 → 2.0.0-internal.7.4.0

package/dist/runtime-definitions-untrimmed.d.ts

@@ -0,0 +1,1117 @@
+import { AttachState } from '@fluidframework/container-definitions';
+import { FluidObject } from '@fluidframework/core-interfaces';
+import { IAudience } from '@fluidframework/container-definitions';
+import { IClientDetails } from '@fluidframework/protocol-definitions';
+import { IdCompressor } from '@fluidframework/id-compressor';
+import { IdCreationRange } from '@fluidframework/id-compressor';
+import { IDeltaManager } from '@fluidframework/container-definitions';
+import { IDisposable } from '@fluidframework/core-interfaces';
+import { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import { IDocumentStorageService } from '@fluidframework/driver-definitions';
+import { IEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { IFluidHandle } from '@fluidframework/core-interfaces';
+import { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import { IFluidRouter } from '@fluidframework/core-interfaces';
+import { IIdCompressor } from '@fluidframework/id-compressor';
+import { IIdCompressorCore } from '@fluidframework/id-compressor';
+import { ILoaderOptions } from '@fluidframework/container-definitions';
+import { initialClusterCapacity } from '@fluidframework/id-compressor';
+import { IProvideFluidHandleContext } from '@fluidframework/core-interfaces';
+import { IQuorumClients } from '@fluidframework/protocol-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResponse } from '@fluidframework/core-interfaces';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISignalMessage } from '@fluidframework/protocol-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryBaseLogger } from '@fluidframework/core-interfaces';
+import { ITree } from '@fluidframework/protocol-definitions';
+import type { IUser } from '@fluidframework/protocol-definitions';
+import { OpSpaceCompressedId } from '@fluidframework/id-compressor';
+import { SerializedIdCompressor } from '@fluidframework/id-compressor';
+import { SerializedIdCompressorWithNoSession } from '@fluidframework/id-compressor';
+import { SerializedIdCompressorWithOngoingSession } from '@fluidframework/id-compressor';
+import { SessionId } from '@fluidframework/id-compressor';
+import { SessionSpaceCompressedId } from '@fluidframework/id-compressor';
+import { StableId } from '@fluidframework/id-compressor';
+import { SummaryTree } from '@fluidframework/protocol-definitions';
+import { TelemetryEventPropertyType } from '@fluidframework/core-interfaces';
+
+/**
+ * Encapsulates the return codes of the aliasing API.
+ *
+ * 'Success' - the datastore has been successfully aliased. It can now be used.
+ * 'Conflict' - there is already a datastore bound to the provided alias. To acquire it's entry point, use
+ * the `IContainerRuntime.getAliasedDataStoreEntryPoint` function. The current datastore should be discarded
+ * and will be garbage collected. The current datastore cannot be aliased to a different value.
+ * 'AlreadyAliased' - the datastore has already been previously bound to another alias name.
+ * @alpha
+ */
+export declare type AliasResult = "Success" | "Conflict" | "AlreadyAliased";
+
+/**
+ * Attribution information associated with a change.
+ * @internal
+ */
+export declare interface AttributionInfo {
+    /**
+     * The user that performed the change.
+     */
+    user: IUser;
+    /**
+     * When the change happened.
+     */
+    timestamp: number;
+}
+
+/**
+ * Can be indexed into the ContainerRuntime in order to retrieve {@link AttributionInfo}.
+ * @alpha
+ */
+export declare type AttributionKey = OpAttributionKey | DetachedAttributionKey | LocalAttributionKey;
+
+/**
+ * @internal
+ */
+export declare const blobCountPropertyName = "BlobCount";
+
+/**
+ * @internal
+ */
+export declare const channelsTreeName = ".channels";
+
+/**
+ * @alpha
+ */
+export declare type CreateChildSummarizerNodeFn = (summarizeInternal: SummarizeInternalFn, getGCDataFn: (fullGC?: boolean) => Promise<IGarbageCollectionData>, 
+/**
+ * @deprecated The functionality to get base GC details has been moved to summarizer node.
+ */
+getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>) => ISummarizerNodeWithGC;
+
+/**
+ * @alpha
+ */
+export declare type CreateChildSummarizerNodeParam = {
+    type: CreateSummarizerNodeSource.FromSummary;
+} | {
+    type: CreateSummarizerNodeSource.FromAttach;
+    sequenceNumber: number;
+    snapshot: ITree;
+} | {
+    type: CreateSummarizerNodeSource.Local;
+};
+
+/**
+ * @alpha
+ */
+export declare enum CreateSummarizerNodeSource {
+    FromSummary = 0,
+    FromAttach = 1,
+    Local = 2
+}
+
+/**
+ * AttributionKey associated with content that was inserted while the container was in a detached state.
+ *
+ * @remarks Retrieving an {@link AttributionInfo} from content associated with detached attribution keys
+ * is currently unsupported, as applications can effectively modify content anonymously while detached.
+ * The runtime has no mechanism for reliably obtaining the user. It would be reasonable to start supporting
+ * this functionality if the host provided additional context to their attributor or attach calls.
+ * @alpha
+ */
+export declare interface DetachedAttributionKey {
+    type: "detached";
+    /**
+     * Arbitrary discriminator associated with content inserted while detached.
+     *
+     * @remarks For now, the runtime assumes all content created while detached is associated
+     * with the same user/timestamp.
+     * We could weaken this assumption in the future with further API support and
+     * allow arbitrary strings or numbers as part of this key.
+     */
+    id: 0;
+}
+
+/**
+ * A single registry entry that may be used to create data stores
+ * It has to have either factory or registry, or both.
+ * @alpha
+ */
+export declare type FluidDataStoreRegistryEntry = Readonly<Partial<IProvideFluidDataStoreRegistry & IProvideFluidDataStoreFactory>>;
+
+/**
+ * Runtime flush mode handling
+ * @alpha
+ */
+export declare enum FlushMode {
+    /**
+     * In Immediate flush mode the runtime will immediately send all operations to the driver layer.
+     */
+    Immediate = 0,
+    /**
+     * When in TurnBased flush mode the runtime will buffer operations in the current turn and send them as a single
+     * batch at the end of the turn. The flush call on the runtime can be used to force send the current batch.
+     */
+    TurnBased = 1
+}
+
+/**
+ * @internal
+ */
+export declare enum FlushModeExperimental {
+    /**
+     * When in Async flush mode, the runtime will accumulate all operations across JS turns and send them as a single
+     * batch when all micro-tasks are complete.
+     *
+     * This feature requires a version of the loader which supports reference sequence numbers. If an older version of
+     * the loader is used, the runtime will fall back on FlushMode.TurnBased.
+     *
+     * @experimental - Not ready for use
+     */
+    Async = 2
+}
+
+/**
+ * They prefix for GC blobs in the GC tree in summary.
+ *
+ * @internal
+ */
+export declare const gcBlobPrefix = "__gc";
+
+/**
+ * The key for deleted nodes blob in the GC tree in summary.
+ *
+ * @internal
+ */
+export declare const gcDeletedBlobKey = "__deletedNodes";
+
+/**
+ * The key for tombstone blob in the GC tree in summary.
+ *
+ * @internal
+ */
+export declare const gcTombstoneBlobKey = "__tombstones";
+
+/**
+ * The key for the GC tree in summary.
+ *
+ * @internal
+ */
+export declare const gcTreeKey = "gc";
+
+/**
+ * Message send by client attaching local data structure.
+ * Contains snapshot of data structure which is the current state of this data structure.
+ * @internal
+ */
+export declare interface IAttachMessage {
+    /**
+     * The identifier for the object
+     */
+    id: string;
+    /**
+     * The type of object
+     */
+    type: string;
+    /**
+     * Initial snapshot of the document (contains ownership)
+     */
+    snapshot: ITree;
+}
+
+/**
+ * A reduced set of functionality of IContainerRuntime that a data store context/data store runtime will need
+ * TODO: this should be merged into IFluidDataStoreContext
+ * @alpha
+ */
+export declare interface IContainerRuntimeBase extends IEventProvider<IContainerRuntimeBaseEvents> {
+    readonly logger: ITelemetryBaseLogger;
+    readonly clientDetails: IClientDetails;
+    /**
+     * Invokes the given callback and guarantees that all operations generated within the callback will be ordered
+     * sequentially. Total size of all messages must be less than maxOpSize.
+     */
+    orderSequentially(callback: () => void): void;
+    /**
+     * Executes a request against the container runtime
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    request(request: IRequest): Promise<IResponse>;
+    /**
+     * Submits a container runtime level signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     */
+    submitSignal(type: string, content: any): void;
+    /**
+     * @deprecated 0.16 Issue #1537, #3631
+     */
+    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
+    /**
+     * Creates a data store and returns an object that exposes a handle to the data store's entryPoint, and also serves
+     * as the data store's router. The data store is not bound to a container, and in such state is not persisted to
+     * storage (file). Storing the entryPoint handle (or any other handle inside the data store, e.g. for DDS) into an
+     * already attached DDS (or non-attached DDS that will eventually get attached to storage) will result in this
+     * store being attached to storage.
+     * @param pkg - Package name of the data store factory
+     */
+    createDataStore(pkg: string | string[]): Promise<IDataStore>;
+    /**
+     * Creates detached data store context. Only after context.attachRuntime() is called,
+     * data store initialization is considered complete.
+     */
+    createDetachedDataStore(pkg: Readonly<string[]>): IFluidDataStoreContextDetached;
+    /**
+     * Get an absolute url for a provided container-relative request.
+     * Returns undefined if the container or data store isn't attached to storage.
+     * @param relativeUrl - A relative request within the container
+     */
+    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    /**
+     * Returns the current quorum.
+     */
+    getQuorum(): IQuorumClients;
+    /**
+     * Returns the current audience.
+     */
+    getAudience(): IAudience;
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    readonly IFluidHandleContext: IFluidHandleContext;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IContainerRuntimeBaseEvents extends IEvent {
+    (event: "batchBegin", listener: (op: ISequencedDocumentMessage) => void): any;
+    /**
+     * @param runtimeMessage - tells if op is runtime op. If it is, it was unpacked, i.e. it's type and content
+     * represent internal container runtime type / content.
+     */
+    (event: "op", listener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void): any;
+    (event: "batchEnd", listener: (error: any, op: ISequencedDocumentMessage) => void): any;
+    (event: "signal", listener: (message: IInboundSignalMessage, local: boolean) => void): any;
+}
+
+/**
+ * Exposes some functionality/features of a data store:
+ * - Handle to the data store's entryPoint
+ * - Fluid router for the data store
+ * - Can be assigned an alias
+ * @alpha
+ */
+export declare interface IDataStore {
+    /**
+     * Attempt to assign an alias to the datastore.
+     * If the operation succeeds, the datastore can be referenced
+     * by the supplied alias and will not be garbage collected.
+     *
+     * @param alias - Given alias for this datastore.
+     * @returns A promise with the {@link AliasResult}
+     */
+    trySetAlias(alias: string): Promise<AliasResult>;
+    /**
+     * Exposes a handle to the root object / entryPoint of the data store. Use this as the primary way of interacting
+     * with it.
+     */
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    /**
+     * @deprecated Requesting will not be supported in a future major release.
+     * Instead, access the objects within the DataStore using entryPoint, and then navigate from there using
+     * app-specific logic (e.g. retrieving a handle from a DDS, or the entryPoint object could implement a request paradigm itself)
+     *
+     * IMPORTANT: This overload is provided for back-compat where IDataStore.request(\{ url: "/" \}) is already implemented and used.
+     * The functionality it can provide (if the DataStore implementation is built for it) is redundant with @see {@link IDataStore.entryPoint}.
+     *
+     * Refer to Removing-IFluidRouter.md for details on migrating from the request pattern to using entryPoint.
+     *
+     * @param request - Only requesting \{ url: "/" \} is supported, requesting arbitrary URLs is deprecated.
+     */
+    request(request: {
+        url: "/";
+        headers?: undefined;
+    }): Promise<IResponse>;
+    /**
+     * Issue a request against the DataStore for a resource within it.
+     * @param request - The request to be issued against the DataStore
+     *
+     * @deprecated Requesting an arbitrary URL with headers will not be supported in a future major release.
+     * Instead, access the objects within the DataStore using entryPoint, and then navigate from there using
+     * app-specific logic (e.g. retrieving a handle from a DDS, or the entryPoint object could implement a request paradigm itself)
+     *
+     * Refer to Removing-IFluidRouter.md for details on migrating from the request pattern to using entryPoint.
+     */
+    request(request: IRequest): Promise<IResponse>;
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    readonly IFluidRouter: IFluidRouter;
+}
+
+export { IdCompressor }
+
+export { IdCreationRange }
+
+/**
+ * An envelope wraps the contents with the intended target
+ * @internal
+ */
+export declare interface IEnvelope {
+    /**
+     * The target for the envelope
+     */
+    address: string;
+    /**
+     * The contents of the envelope
+     */
+    contents: any;
+}
+
+/**
+ * @experimental - Can be deleted/changed at any time
+ * Contains the necessary information to allow DDSes to do incremental summaries
+ * @alpha
+ */
+export declare interface IExperimentalIncrementalSummaryContext {
+    /**
+     * The sequence number of the summary generated that will be sent to the server.
+     */
+    summarySequenceNumber: number;
+    /**
+     * The sequence number of the most recent summary that was acknowledged by the server.
+     */
+    latestSummarySequenceNumber: number;
+    /**
+     * The path to the runtime/datastore/dds that is used to generate summary handles
+     * Note: Summary handles are nodes of the summary tree that point to previous parts of the last successful summary
+     * instead of being a blob or tree node
+     *
+     * This path contains the id of the data store and dds which should not be leaked to layers below them. Ideally,
+     * a layer should not know its own id. This is important for channel unification work and there has been a lot of
+     * work to remove these kinds of leakages. Some still exist, which have to be fixed but we should not be adding
+     * more dependencies.
+     */
+    summaryPath: string;
+}
+
+/**
+ * Minimal interface a data store runtime needs to provide for IFluidDataStoreContext to bind to control.
+ *
+ * Functionality include attach, snapshot, op/signal processing, request routes, expose an entryPoint,
+ * and connection state notifications
+ * @alpha
+ */
+export declare interface IFluidDataStoreChannel extends IDisposable {
+    readonly id: string;
+    /**
+     * Indicates the attachment state of the channel to a host service.
+     */
+    readonly attachState: AttachState;
+    readonly visibilityState: VisibilityState;
+    /**
+     * Runs through the graph and attaches the bound handles. Then binds this runtime to the container.
+     * @deprecated This will be removed in favor of {@link IFluidDataStoreChannel.makeVisibleAndAttachGraph}.
+     */
+    attachGraph(): void;
+    /**
+     * Makes the data store channel visible in the container. Also, runs through its graph and attaches all
+     * bound handles that represent its dependencies in the container's graph.
+     */
+    makeVisibleAndAttachGraph(): void;
+    /**
+     * Retrieves the summary used as part of the initial summary message
+     */
+    getAttachSummary(telemetryContext?: ITelemetryContext): ISummaryTreeWithStats;
+    /**
+     * Processes the op.
+     */
+    process(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
+    /**
+     * Processes the signal.
+     */
+    processSignal(message: any, local: boolean): void;
+    /**
+     * Generates a summary for the channel.
+     * Introduced with summarizerNode - will be required in a future release.
+     * @param fullTree - true to bypass optimizations and force a full summary tree.
+     * @param trackState - This tells whether we should track state from this summary.
+     * @param telemetryContext - summary data passed through the layers for telemetry purposes
+     */
+    summarize(fullTree?: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): Promise<ISummaryTreeWithStats>;
+    /**
+     * Returns the data used for garbage collection. This includes a list of GC nodes that represent this context
+     * including any of its children. Each node has a list of outbound routes to other GC nodes in the document.
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    /**
+     * After GC has run, called to notify this channel of routes that are used in it.
+     * @param usedRoutes - The routes that are used in this channel.
+     */
+    updateUsedRoutes(usedRoutes: string[]): void;
+    /**
+     * Notifies this object about changes in the connection state.
+     * @param value - New connection state.
+     * @param clientId - ID of the client. It's old ID when in disconnected state and
+     * it's new client ID when we are connecting or connected.
+     */
+    setConnectionState(connected: boolean, clientId?: string): any;
+    /**
+     * Ask the DDS to resubmit a message. This could be because we reconnected and this message was not acked.
+     * @param type - The type of the original message.
+     * @param content - The content of the original message.
+     * @param localOpMetadata - The local metadata associated with the original message.
+     */
+    reSubmit(type: string, content: any, localOpMetadata: unknown): any;
+    applyStashedOp(content: any): Promise<unknown>;
+    /**
+     * Revert a local message.
+     * @param type - The type of the original message.
+     * @param content - The content of the original message.
+     * @param localOpMetadata - The local metadata associated with the original message.
+     */
+    rollback?(type: string, content: any, localOpMetadata: unknown): void;
+    /**
+     * Exposes a handle to the root object / entryPoint of the component. Use this as the primary way of interacting
+     * with the component.
+     */
+    readonly entryPoint: IFluidHandle<FluidObject>;
+    request(request: IRequest): Promise<IResponse>;
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    readonly IFluidRouter: IFluidRouter;
+}
+
+/**
+ * Represents the context for the data store. It is used by the data store runtime to
+ * get information and call functionality to the container.
+ * @alpha
+ */
+export declare interface IFluidDataStoreContext extends IEventProvider<IFluidDataStoreContextEvents>, Partial<IProvideFluidDataStoreRegistry>, IProvideFluidHandleContext {
+    readonly id: string;
+    /**
+     * A data store created by a client, is a local data store for that client. Also, when a detached container loads
+     * from a snapshot, all the data stores are treated as local data stores because at that stage the container
+     * still doesn't exists in storage and so the data store couldn't have been created by any other client.
+     * Value of this never changes even after the data store is attached.
+     * As implementer of data store runtime, you can use this property to check that this data store belongs to this
+     * client and hence implement any scenario based on that.
+     */
+    readonly isLocalDataStore: boolean;
+    /**
+     * The package path of the data store as per the package factory.
+     */
+    readonly packagePath: readonly string[];
+    readonly options: ILoaderOptions;
+    readonly clientId: string | undefined;
+    readonly connected: boolean;
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    readonly storage: IDocumentStorageService;
+    readonly baseSnapshot: ISnapshotTree | undefined;
+    readonly logger: ITelemetryBaseLogger;
+    readonly clientDetails: IClientDetails;
+    readonly idCompressor?: IIdCompressor;
+    /**
+     * Indicates the attachment state of the data store to a host service.
+     */
+    readonly attachState: AttachState;
+    readonly containerRuntime: IContainerRuntimeBase;
+    /**
+     * @deprecated 0.16 Issue #1635, #3631
+     */
+    readonly createProps?: any;
+    /**
+     * Ambient services provided with the context
+     */
+    readonly scope: FluidObject;
+    /**
+     * Returns the current quorum.
+     */
+    getQuorum(): IQuorumClients;
+    /**
+     * Returns the current audience.
+     */
+    getAudience(): IAudience;
+    /**
+     * Invokes the given callback and expects that no ops are submitted
+     * until execution finishes. If an op is submitted, an error will be raised.
+     *
+     * Can be disabled by feature gate `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     *
+     * @param callback - the callback to be invoked
+     */
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    /**
+     * Submits the message to be sent to other clients.
+     * @param type - Type of the message.
+     * @param content - Content of the message.
+     * @param localOpMetadata - The local metadata associated with the message. This is kept locally and not sent to
+     * the server. This will be sent back when this message is received back from the server. This is also sent if
+     * we are asked to resubmit the message.
+     */
+    submitMessage(type: string, content: any, localOpMetadata: unknown): void;
+    /**
+     * Submits the signal to be sent to other clients.
+     * @param type - Type of the signal.
+     * @param content - Content of the signal.
+     * @param targetClientId - When specified, the signal is only sent to the provided client id.
+     */
+    submitSignal(type: string, content: any, targetClientId?: string): void;
+    /**
+     * Called to make the data store locally visible in the container. This happens automatically for root data stores
+     * when they are marked as root. For non-root data stores, this happens when their handle is added to a visible DDS.
+     */
+    makeLocallyVisible(): void;
+    /**
+     * Call by IFluidDataStoreChannel, indicates that a channel is dirty and needs to be part of the summary.
+     * @param address - The address of the channel that is dirty.
+     */
+    setChannelDirty(address: string): void;
+    /**
+     * Get an absolute url to the container based on the provided relativeUrl.
+     * Returns undefined if the container or data store isn't attached to storage.
+     * @param relativeUrl - A relative request within the container
+     */
+    getAbsoluteUrl(relativeUrl: string): Promise<string | undefined>;
+    getCreateChildSummarizerNodeFn(
+    /**
+     * Initial id or path part of this node
+     */
+    id: string, 
+    /**
+     * Information needed to create the node.
+     * If it is from a base summary, it will assert that a summary has been seen.
+     * Attach information if it is created from an attach op.
+     * If it is local, it will throw unsupported errors on calls to summarize.
+     */
+    createParam: CreateChildSummarizerNodeParam): CreateChildSummarizerNodeFn;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    /**
+     * @deprecated The functionality to get base GC details has been moved to summarizer node.
+     *
+     * Returns the GC details in the initial summary of this data store. This is used to initialize the data store
+     * and its children with the GC details from the previous summary.
+     */
+    getBaseGCDetails(): Promise<IGarbageCollectionDetailsBase>;
+    /**
+     * Called when a new outbound reference is added to another node. This is used by garbage collection to identify
+     * all references added in the system.
+     * @param srcHandle - The handle of the node that added the reference.
+     * @param outboundHandle - The handle of the outbound node that is referenced.
+     */
+    addedGCOutboundReference?(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IFluidDataStoreContextDetached extends IFluidDataStoreContext {
+    /**
+     * Binds a runtime to the context.
+     */
+    attachRuntime(factory: IProvideFluidDataStoreFactory, dataStoreRuntime: IFluidDataStoreChannel): Promise<void>;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IFluidDataStoreContextEvents extends IEvent {
+    (event: "attaching" | "attached", listener: () => void): any;
+}
+
+/**
+ * @alpha
+ */
+export declare const IFluidDataStoreFactory: keyof IProvideFluidDataStoreFactory;
+
+/**
+ * IFluidDataStoreFactory create data stores.  It is associated with an identifier (its `type` member)
+ * and usually provided to consumers using this mapping through a data store registry.
+ * @alpha
+ */
+export declare interface IFluidDataStoreFactory extends IProvideFluidDataStoreFactory {
+    /**
+     * String that uniquely identifies the type of data store created by this factory.
+     */
+    type: string;
+    /**
+     * Generates runtime for the data store from the data store context. Once created should be bound to the context.
+     * @param context - Context for the data store.
+     * @param existing - If instantiating from an existing file.
+     */
+    instantiateDataStore(context: IFluidDataStoreContext, existing: boolean): Promise<IFluidDataStoreChannel>;
+}
+
+/**
+ * @alpha
+ */
+export declare const IFluidDataStoreRegistry: keyof IProvideFluidDataStoreRegistry;
+
+/**
+ * An association of identifiers to data store registry entries, where the
+ * entries can be used to create data stores.
+ * @alpha
+ */
+export declare interface IFluidDataStoreRegistry extends IProvideFluidDataStoreRegistry {
+    get(name: string): Promise<FluidDataStoreRegistryEntry | undefined>;
+}
+
+/**
+ * Garbage collection data returned by nodes in a Container.
+ * Used for running GC in the Container.
+ * @alpha
+ */
+export declare interface IGarbageCollectionData {
+    /**
+     * The GC nodes of a Fluid object in the Container. Each node has an id and a set of routes to other GC nodes.
+     */
+    gcNodes: {
+        [id: string]: string[];
+    };
+}
+
+/**
+ * GC details provided to each node during creation.
+ * @alpha
+ */
+export declare interface IGarbageCollectionDetailsBase {
+    /**
+     * A list of routes to Fluid objects that are used in this node.
+     */
+    usedRoutes?: string[];
+    /**
+     * The GC data of this node.
+     */
+    gcData?: IGarbageCollectionData;
+}
+
+export { IIdCompressor }
+
+export { IIdCompressorCore }
+
+/**
+ * Represents ISignalMessage with its type.
+ * @alpha
+ */
+export declare interface IInboundSignalMessage extends ISignalMessage {
+    type: string;
+}
+
+/**
+ * This type should be used when reading an incoming attach op,
+ * but it should not be used when creating a new attach op.
+ * Older versions of attach messages could have null snapshots,
+ * so this gives correct typings for writing backward compatible code.
+ * @internal
+ */
+export declare type InboundAttachMessage = Omit<IAttachMessage, "snapshot"> & {
+    snapshot: IAttachMessage["snapshot"] | null;
+};
+
+export { initialClusterCapacity }
+
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidDataStoreFactory {
+    readonly IFluidDataStoreFactory: IFluidDataStoreFactory;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidDataStoreRegistry {
+    readonly IFluidDataStoreRegistry: IFluidDataStoreRegistry;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISignalEnvelope {
+    /**
+     * The target for the envelope, undefined for the container
+     */
+    address?: string;
+    /**
+     * Identifier for the signal being submitted.
+     */
+    clientSignalSequenceNumber: number;
+    /**
+     * The contents of the envelope
+     */
+    contents: {
+        type: string;
+        content: any;
+    };
+}
+
+/**
+ * Contains the same data as ISummaryResult but in order to avoid naming collisions,
+ * the data store summaries are wrapped around an array of labels identified by pathPartsForChildren.
+ *
+ * @example
+ *
+ * ```typescript
+ * id:""
+ * pathPartsForChildren: ["path1"]
+ * stats: ...
+ * summary:
+ *   ...
+ *     "path1":
+ * ```
+ * @alpha
+ */
+export declare interface ISummarizeInternalResult extends ISummarizeResult {
+    id: string;
+    /**
+     * Additional path parts between this node's ID and its children's IDs.
+     */
+    pathPartsForChildren?: string[];
+}
+
+/**
+ * Represents a summary at a current sequence number.
+ * @alpha
+ */
+export declare interface ISummarizeResult {
+    stats: ISummaryStats;
+    summary: SummaryTree;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerNode {
+    /**
+     * Latest successfully acked summary reference sequence number
+     */
+    readonly referenceSequenceNumber: number;
+    /**
+     * Marks the node as having a change with the given sequence number.
+     * @param sequenceNumber - sequence number of change
+     */
+    invalidate(sequenceNumber: number): void;
+    /**
+     * Calls the internal summarize function and handles internal state tracking.
+     * If unchanged and fullTree is false, it will reuse previous summary subtree.
+     * If an error is encountered and throwOnFailure is false, it will try to make
+     * a summary with a pointer to the previous summary + a blob of outstanding ops.
+     * @param fullTree - true to skip optimizations and always generate the full tree
+     * @param trackState - indicates whether the summarizer node should track the state of the summary or not
+     * @param telemetryContext - summary data passed through the layers for telemetry purposes
+     */
+    summarize(fullTree: boolean, trackState?: boolean, telemetryContext?: ITelemetryContext): Promise<ISummarizeResult>;
+    /**
+     * Checks if there are any additional path parts for children that need to
+     * be loaded from the base summary. Additional path parts represent parts
+     * of the path between this SummarizerNode and any child SummarizerNodes
+     * that it might have. For example: if datastore "a" contains dds "b", but the
+     * path is "/a/.channels/b", then the additional path part is ".channels".
+     * @param snapshot - the base summary to parse
+     */
+    updateBaseSummaryState(snapshot: ISnapshotTree): void;
+    /**
+     * Records an op representing a change to this node/subtree.
+     * @param op - op of change to record
+     */
+    recordChange(op: ISequencedDocumentMessage): void;
+    createChild(
+    /**
+     * Summarize function
+     */
+    summarizeInternalFn: SummarizeInternalFn, 
+    /**
+     * Initial id or path part of this node
+     */
+    id: string, 
+    /**
+     * Information needed to create the node.
+     * If it is from a base summary, it will assert that a summary has been seen.
+     * Attach information if it is created from an attach op.
+     * If it is local, it will throw unsupported errors on calls to summarize.
+     */
+    createParam: CreateChildSummarizerNodeParam, 
+    /**
+     * Optional configuration affecting summarize behavior
+     */
+    config?: ISummarizerNodeConfig): ISummarizerNode;
+    getChild(id: string): ISummarizerNode | undefined;
+    /** True if a summary is currently in progress */
+    isSummaryInProgress?(): boolean;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerNodeConfig {
+    /**
+     * True to reuse previous handle when unchanged since last acked summary.
+     * Defaults to true.
+     */
+    readonly canReuseHandle?: boolean;
+    /**
+     * True to always stop execution on error during summarize, or false to
+     * attempt creating a summary that is a pointer ot the last acked summary
+     * plus outstanding ops in case of internal summarize failure.
+     * Defaults to false.
+     *
+     * BUG BUG: Default to true while we investigate problem
+     * with differential summaries
+     */
+    readonly throwOnFailure?: true;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerNodeConfigWithGC extends ISummarizerNodeConfig {
+    /**
+     * True if GC is disabled. If so, don't track GC related state for a summary.
+     * This is propagated to all child nodes.
+     */
+    readonly gcDisabled?: boolean;
+}
+
+/**
+ * Extends the functionality of ISummarizerNode to support garbage collection. It adds / updates the following APIs:
+ *
+ * `usedRoutes`: The routes in this node that are currently in use.
+ *
+ * `getGCData`: A new API that can be used to get the garbage collection data for this node.
+ *
+ * `summarize`: Added a trackState flag which indicates whether the summarizer node should track the state of the
+ * summary or not.
+ *
+ * `createChild`: Added the following params:
+ *
+ * - `getGCDataFn`: This gets the GC data from the caller. This must be provided in order for getGCData to work.
+ *
+ * - `getInitialGCDetailsFn`: This gets the initial GC details from the caller.
+ *
+ * `deleteChild`: Deletes a child node.
+ *
+ * `isReferenced`: This tells whether this node is referenced in the document or not.
+ *
+ * `updateUsedRoutes`: Used to notify this node of routes that are currently in use in it.
+ * @alpha
+ */
+export declare interface ISummarizerNodeWithGC extends ISummarizerNode {
+    createChild(
+    /**
+     * Summarize function
+     */
+    summarizeInternalFn: SummarizeInternalFn, 
+    /**
+     * Initial id or path part of this node
+     */
+    id: string, 
+    /**
+     * Information needed to create the node.
+     * If it is from a base summary, it will assert that a summary has been seen.
+     * Attach information if it is created from an attach op.
+     * If it is local, it will throw unsupported errors on calls to summarize.
+     */
+    createParam: CreateChildSummarizerNodeParam, 
+    /**
+     * Optional configuration affecting summarize behavior
+     */
+    config?: ISummarizerNodeConfigWithGC, getGCDataFn?: (fullGC?: boolean) => Promise<IGarbageCollectionData>, 
+    /**
+     * @deprecated The functionality to update child's base GC details is incorporated in the summarizer node.
+     */
+    getBaseGCDetailsFn?: () => Promise<IGarbageCollectionDetailsBase>): ISummarizerNodeWithGC;
+    /**
+     * Delete the child with the given id..
+     */
+    deleteChild(id: string): void;
+    getChild(id: string): ISummarizerNodeWithGC | undefined;
+    /**
+     * Returns this node's data that is used for garbage collection. This includes a list of GC nodes that represent
+     * this node. Each node has a set of outbound routes to other GC nodes in the document.
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     */
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    /**
+     * Tells whether this node is being referenced in this document or not. Unreferenced node will get GC'd
+     */
+    isReferenced(): boolean;
+    /**
+     * After GC has run, called to notify this node of routes that are used in it. These are used for the following:
+     * 1. To identify if this node is being referenced in the document or not.
+     * 2. To identify if this node or any of its children's used routes changed since last summary.
+     *
+     * @param usedRoutes - The routes that are used in this node.
+     */
+    updateUsedRoutes(usedRoutes: string[]): void;
+}
+
+/**
+ * Contains the aggregation data from a Tree/Subtree.
+ * @alpha
+ */
+export declare interface ISummaryStats {
+    treeNodeCount: number;
+    blobNodeCount: number;
+    handleNodeCount: number;
+    totalBlobSize: number;
+    unreferencedBlobSize: number;
+}
+
+/**
+ * Represents the summary tree for a node along with the statistics for that tree.
+ * For example, for a given data store, it contains the data for data store along with a subtree for
+ * each of its DDS.
+ * Any component that implements IChannelContext, IFluidDataStoreChannel or extends SharedObject
+ * will be taking part of the summarization process.
+ * @alpha
+ */
+export declare interface ISummaryTreeWithStats {
+    /**
+     * Represents an aggregation of node counts and blob sizes associated to the current summary information
+     */
+    stats: ISummaryStats;
+    /**
+     * A recursive data structure that will be converted to a snapshot tree and uploaded
+     * to the backend.
+     */
+    summary: ISummaryTree;
+}
+
+/**
+ * Contains telemetry data relevant to summarization workflows.
+ * This object is expected to be modified directly by various summarize methods.
+ * @alpha
+ */
+export declare interface ITelemetryContext {
+    /**
+     * Sets value for telemetry data being tracked.
+     * @param prefix - unique prefix to tag this data with (ex: "fluid:map:")
+     * @param property - property name of the telemetry data being tracked (ex: "DirectoryCount")
+     * @param value - value to attribute to this summary telemetry data
+     */
+    set(prefix: string, property: string, value: TelemetryEventPropertyType): void;
+    /**
+     * Sets multiple values for telemetry data being tracked.
+     * @param prefix - unique prefix to tag this data with (ex: "fluid:summarize:")
+     * @param property - property name of the telemetry data being tracked (ex: "Options")
+     * @param values - A set of values to attribute to this summary telemetry data.
+     */
+    setMultiple(prefix: string, property: string, values: Record<string, TelemetryEventPropertyType>): void;
+    /**
+     * Get the telemetry data being tracked
+     * @param prefix - unique prefix for this data (ex: "fluid:map:")
+     * @param property - property name of the telemetry data being tracked (ex: "DirectoryCount")
+     * @returns undefined if item not found
+     */
+    get(prefix: string, property: string): TelemetryEventPropertyType;
+    /**
+     * Returns a serialized version of all the telemetry data.
+     * Should be used when logging in telemetry events.
+     */
+    serialize(): string;
+}
+
+/**
+ * AttributionKey associated with content that has been made locally but not yet acked by the server.
+ * @alpha
+ */
+export declare interface LocalAttributionKey {
+    type: "local";
+}
+
+/**
+ * An iterable identifier/registry entry pair list
+ * @alpha
+ */
+export declare type NamedFluidDataStoreRegistryEntries = Iterable<NamedFluidDataStoreRegistryEntry>;
+
+/**
+ * An associated pair of an identifier and registry entry.  Registry entries
+ * may be dynamically loaded.
+ * @alpha
+ */
+export declare type NamedFluidDataStoreRegistryEntry = [string, Promise<FluidDataStoreRegistryEntry>];
+
+/**
+ * AttributionKey representing a reference to some op in the op stream.
+ * Content associated with this key aligns with content modified by that op.
+ * @alpha
+ */
+export declare interface OpAttributionKey {
+    /**
+     * The type of attribution this key corresponds to.
+     *
+     * Keys currently all represent op-based attribution, so have the form `{ type: "op", key: sequenceNumber }`.
+     * Thus, they can be used with an `OpStreamAttributor` to recover timestamp/user information.
+     */
+    type: "op";
+    /**
+     * The sequenceNumber of the op this attribution key is for.
+     */
+    seq: number;
+}
+
+export { OpSpaceCompressedId }
+
+export { SerializedIdCompressor }
+
+export { SerializedIdCompressorWithNoSession }
+
+export { SerializedIdCompressorWithOngoingSession }
+
+export { SessionId }
+
+export { SessionSpaceCompressedId }
+
+export { StableId }
+
+/**
+ * @alpha
+ */
+export declare type SummarizeInternalFn = (fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext) => Promise<ISummarizeInternalResult>;
+
+/**
+ * @internal
+ */
+export declare const totalBlobSizePropertyName = "TotalBlobSize";
+
+/**
+ * This tells the visibility state of a Fluid object. It basically tracks whether the object is not visible, visible
+ * locally within the container only or visible globally to all clients.
+ * @alpha
+ */
+export declare const VisibilityState: {
+    /**
+     * Indicates that the object is not visible. This is the state when an object is first created.
+     */
+    NotVisible: string;
+    /**
+     * Indicates that the object is visible locally within the container. This is the state when an object is attached
+     * to the container's graph but the container itself isn't globally visible. The object's state goes from not
+     * visible to locally visible.
+     */
+    LocallyVisible: string;
+    /**
+     * Indicates that the object is visible globally to all clients. This is the state of an object in 2 scenarios:
+     *
+     * 1. It is attached to the container's graph when the container is globally visible. The object's state goes from
+     * not visible to globally visible.
+     *
+     * 2. When a container becomes globally visible, all locally visible objects go from locally visible to globally
+     * visible.
+     */
+    GloballyVisible: string;
+};
+
+/**
+ * @alpha
+ */
+export declare type VisibilityState = (typeof VisibilityState)[keyof typeof VisibilityState];
+
+export { }