@fluidframework/runtime-definitions 2.0.0-dev.7.4.0.217212 → 2.0.0-dev.7.4.0.217884

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

@@ -8,8 +8,11 @@ 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 { ILoaderOptions } from '@fluidframework/container-definitions';
+import { IProvideFluidHandleContext } from '@fluidframework/core-interfaces';
 import { IQuorumClients } from '@fluidframework/protocol-definitions';
 import { IRequest } from '@fluidframework/core-interfaces';
 import { IResponse } from '@fluidframework/core-interfaces';
@@ -23,7 +26,17 @@ import type { IUser } from '@fluidframework/protocol-definitions';
 import { SummaryTree } from '@fluidframework/protocol-definitions';
 import { TelemetryEventPropertyType } from '@fluidframework/core-interfaces';
 
-/* Excluded from this release type: AliasResult */
+/**
+ * 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";
 
 /* Excluded from this release type: AttributionInfo */
 
@@ -33,17 +46,61 @@ import { TelemetryEventPropertyType } from '@fluidframework/core-interfaces';
 
 /* Excluded from this release type: channelsTreeName */
 
-/* Excluded from this release type: CreateChildSummarizerNodeFn */
-
-/* Excluded from this release type: CreateChildSummarizerNodeParam */
-
-/* Excluded from this release type: CreateSummarizerNodeSource */
+/**
+ * @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
+}
 
 /* Excluded from this release type: DetachedAttributionKey */
 
-/* Excluded from this release type: FluidDataStoreRegistryEntry */
-
-/* Excluded from this release type: FlushMode */
+/**
+ * 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
+}
 
 /* Excluded from this release type: FlushModeExperimental */
 
@@ -57,100 +114,1019 @@ import { TelemetryEventPropertyType } from '@fluidframework/core-interfaces';
 
 /* Excluded from this release type: IAttachMessage */
 
-/* Excluded from this release type: IContainerRuntimeBase */
-
-/* Excluded from this release type: IContainerRuntimeBaseEvents */
-
-/* Excluded from this release type: IDataStore */
-
-/* Excluded from this release type: IdCreationRange */
+/**
+ * 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;
+}
+
+/**
+ * Data describing a range of session-local IDs (from a remote or local session).
+ *
+ * A range is composed of local IDs that were generated.
+ * @alpha
+ */
+export declare interface IdCreationRange {
+    readonly sessionId: SessionId;
+    readonly ids?: {
+        readonly firstGenCount: number;
+        readonly count: number;
+    };
+}
 
 /* Excluded from this release type: IEnvelope */
 
-/* Excluded from this release type: IExperimentalIncrementalSummaryContext */
-
-/* Excluded from this release type: IFluidDataStoreChannel */
-
-/* Excluded from this release type: IFluidDataStoreContext */
-
-/* Excluded from this release type: IFluidDataStoreContextDetached */
-
-/* Excluded from this release type: IFluidDataStoreContextEvents */
-
-/* Excluded from this release type: IFluidDataStoreFactory */
-
-/* Excluded from this release type: IFluidDataStoreRegistry */
-
-/* Excluded from this release type: IFluidHandle */
-
-/* Excluded from this release type: IFluidHandleContext */
-
-/* Excluded from this release type: IGarbageCollectionData */
-
-/* Excluded from this release type: IGarbageCollectionDetailsBase */
-
-/* Excluded from this release type: IIdCompressor */
-
-/* Excluded from this release type: IIdCompressorCore */
-
-/* Excluded from this release type: IInboundSignalMessage */
+/**
+ * @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;
+}
+
+/**
+ * A distributed UUID generator and compressor.
+ *
+ * Generates arbitrary non-colliding v4 UUIDs, called stable IDs, for multiple "sessions" (which can be distributed across the network),
+ * providing each session with the ability to map these UUIDs to `numbers`.
+ *
+ * A session is a unique identifier that denotes a single compressor. New IDs are created through a single compressor API
+ * which should then sent in ranges to the server for total ordering (and are subsequently relayed to other clients). When a new ID is
+ * created it is said to be created by the compressor's "local" session.
+ *
+ * For each stable ID created, two numeric IDs are provided by the compressor:
+ *
+ * 1. A session-local ID, which is stable for the lifetime of the session (which could be longer than that of the compressor object, as it may
+ * be serialized for offline usage). Available as soon as the stable ID is allocated. These IDs are session-unique and are thus only
+ * safely usable within the scope of the compressor that created it.
+ *
+ * 2. A final ID, which is stable across serialization and deserialization of an IdCompressor. Available as soon as the range containing
+ * the corresponding session-local ID is totally ordered (via consensus) with respect to other sessions' allocations.
+ * Final IDs are known to and publicly usable by any compressor that has received them.
+ *
+ * Compressors will allocate UUIDs in non-random ways to reduce entropy allowing for optimized storage of the data needed
+ * to map the UUIDs to the numbers.
+ *
+ * The following invariants are upheld by IdCompressor:
+ *
+ * 1. Session-local IDs will always decompress to the same UUIDs for the lifetime of the session.
+ *
+ * 2. Final IDs will always decompress to the same UUIDs.
+ *
+ * 3. After a server-processed range of session-local IDs (from any session) is received by a compressor, any of those session-local IDs may be
+ * translated by the compressor into the corresponding final ID. For any given session-local ID, this translation will always yield the
+ * same final ID.
+ *
+ * 4. A UUID will always compress into the same session-local ID for the lifetime of the session.
+ *
+ * Session-local IDs are sent across the wire in efficiently-represented ranges. These ranges are created by querying the compressor, and *must*
+ * be ordered (i.e. sent to the server) in the order they are created in order to preserve the above invariants.
+ *
+ * Session-local IDs can be used immediately after creation, but will eventually (after being sequenced) have a corresponding final ID. This
+ * could make reasoning about equality of those two forms difficult. For example, if a cache is keyed off of a
+ * session-local ID but is later queried using the final ID (which is semantically equal, as it decompresses to the same UUID/string) it will
+ * produce a cache miss. In order to make using collections of both remotely created and locally created IDs easy, regardless of whether the
+ * session-local IDs have been finalized, the compressor defines two "spaces" of IDs:
+ *
+ * 1. Session space: in this space, all IDs are normalized to their "most local form". This means that all IDs created by the local session
+ * will be in local form, regardless of if they have been finalized. Remotely created IDs, which could only have been received after
+ * finalizing and will never have a local form for the compressor, will of course be final IDs. This space should be used with consumer APIs
+ * and data structures, as the lifetime of the IDs is guaranteed to be the same as the compressor object. Care must be taken to not use
+ * these IDs across compressor objects, as the local IDs are specific to the compressor that created them.
+ *
+ * 2. Op space: in this space, all IDs are normalized to their "most final form". This means that all IDs except session-local IDs that
+ * have not yet been finalized will be in final ID form. This space is useful for serialization in ops (e.g. references), as other clients
+ * that receive them need not do any work to normalize them to *their* session-space in the common case. Note that IDs in op space may move
+ * out of Op space over time, namely, when a session-local ID in this space becomes finalized, and thereafter has a "more final form".
+ * Consequentially, it may be useful to restrict parameters of a persisted type to this space (to optimize perf), but it is potentially
+ * incorrect to use this type for a runtime variable. This is an asymmetry that does not affect session space, as local IDs are always as
+ * "local as possible".
+ *
+ * These two spaces naturally define a rule: consumers of compressed IDs should use session-space IDs, but serialized forms such as ops
+ * should use op-space IDs.
+ * @alpha
+ */
+export declare interface IIdCompressor {
+    localSessionId: SessionId;
+    /**
+     * Generates a new compressed ID or returns an existing one.
+     * This should ONLY be called to generate IDs for local operations.
+     * @returns A new local ID in session space.
+     */
+    generateCompressedId(): SessionSpaceCompressedId;
+    /**
+     * Normalizes a session space ID into op space.
+     * @param id - the local ID to normalize.
+     * @returns the ID in op space.
+     */
+    normalizeToOpSpace(id: SessionSpaceCompressedId): OpSpaceCompressedId;
+    /**
+     * Normalizes an ID into session space.
+     * @param id - the ID to normalize. If it is a local ID, it is assumed to have been created by the session corresponding
+     * to `sessionId`.
+     * @param originSessionId - the session from which `id` originated
+     * @returns the session-space ID corresponding to `id`, which might not have been a final ID if the client that created it had not yet
+     * finalized it. This can occur when a client references an ID during the window of time in which it is waiting to receive the ordered
+     * range that contained it from the server.
+     */
+    normalizeToSessionSpace(id: OpSpaceCompressedId, originSessionId: SessionId): SessionSpaceCompressedId;
+    /**
+     * Decompresses a previously compressed ID into a UUID.
+     * @param id - the compressed ID to be decompressed.
+     * @returns the UUID associated with the compressed ID. Fails if the ID was not generated by this compressor.
+     */
+    decompress(id: SessionSpaceCompressedId): StableId;
+    /**
+     * Recompresses a UUID.
+     * @param uncompressed - the UUID to recompress.
+     * @returns the `CompressedId` associated with `uncompressed`. Fails if it has not been previously compressed by this compressor.
+     */
+    recompress(uncompressed: StableId): SessionSpaceCompressedId;
+    /**
+     * Attempts to recompresses a UUID.
+     * @param uncompressed - the UUID to recompress,
+     * @returns the `CompressedId` associated with `uncompressed` or undefined if it has not been previously compressed by this compressor.
+     */
+    tryRecompress(uncompressed: StableId): SessionSpaceCompressedId | undefined;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IIdCompressorCore {
+    /**
+     * Returns a range of IDs created by this session in a format for sending to the server for finalizing.
+     * The range will include all IDs generated via calls to `generateCompressedId` since the last time this method was called.
+     * @returns the range of IDs, which may be empty. This range must be sent to the server for ordering before
+     * it is finalized. Ranges must be sent to the server in the order that they are taken via calls to this method.
+     */
+    takeNextCreationRange(): IdCreationRange;
+    /**
+     * Finalizes the supplied range of IDs (which may be from either a remote or local session).
+     * @param range - the range of session-local IDs to finalize.
+     */
+    finalizeCreationRange(range: IdCreationRange): void;
+    /**
+     * Returns a persistable form of the current state of this `IdCompressor` which can be rehydrated via `IdCompressor.deserialize()`.
+     * This includes finalized state as well as un-finalized state and is therefore suitable for use in offline scenarios.
+     */
+    serialize(withSession: true): SerializedIdCompressorWithOngoingSession;
+    /**
+     * Returns a persistable form of the current state of this `IdCompressor` which can be rehydrated via `IdCompressor.deserialize()`.
+     * This only includes finalized state and is therefore suitable for use in summaries.
+     */
+    serialize(withSession: false): SerializedIdCompressorWithNoSession;
+}
+
+/**
+ * Represents ISignalMessage with its type.
+ * @alpha
+ */
+export declare interface IInboundSignalMessage extends ISignalMessage {
+    type: string;
+}
 
 /* Excluded from this release type: InboundAttachMessage */
 
 /* Excluded from this release type: initialClusterCapacity */
 
-/* Excluded from this release type: IProvideFluidDataStoreFactory */
-
-/* Excluded from this release type: IProvideFluidDataStoreRegistry */
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidDataStoreFactory {
+    readonly IFluidDataStoreFactory: IFluidDataStoreFactory;
+}
 
-/* Excluded from this release type: IProvideFluidHandleContext */
+/**
+ * @alpha
+ */
+export declare interface IProvideFluidDataStoreRegistry {
+    readonly IFluidDataStoreRegistry: IFluidDataStoreRegistry;
+}
 
 /* Excluded from this release type: ISignalEnvelope */
 
-/* Excluded from this release type: ISummarizeInternalResult */
-
-/* Excluded from this release type: ISummarizeResult */
-
-/* Excluded from this release type: ISummarizerNode */
-
-/* Excluded from this release type: ISummarizerNodeConfig */
-
-/* Excluded from this release type: ISummarizerNodeConfigWithGC */
-
-/* Excluded from this release type: ISummarizerNodeWithGC */
-
-/* Excluded from this release type: ISummaryStats */
-
-/* Excluded from this release type: ISummaryTreeWithStats */
-
-/* Excluded from this release type: ITelemetryContext */
+/**
+ * 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;
+}
 
 /* Excluded from this release type: LocalAttributionKey */
 
-/* Excluded from this release type: NamedFluidDataStoreRegistryEntries */
+/**
+ * An iterable identifier/registry entry pair list
+ * @alpha
+ */
+export declare type NamedFluidDataStoreRegistryEntries = Iterable<NamedFluidDataStoreRegistryEntry>;
 
-/* Excluded from this release type: NamedFluidDataStoreRegistryEntry */
+/**
+ * An associated pair of an identifier and registry entry.  Registry entries
+ * may be dynamically loaded.
+ * @alpha
+ */
+export declare type NamedFluidDataStoreRegistryEntry = [string, Promise<FluidDataStoreRegistryEntry>];
 
 /* Excluded from this release type: OpAttributionKey */
 
-/* Excluded from this release type: OpSpaceCompressedId */
-
-/* Excluded from this release type: SerializedIdCompressor */
-
-/* Excluded from this release type: SerializedIdCompressorWithNoSession */
-
-/* Excluded from this release type: SerializedIdCompressorWithOngoingSession */
-
-/* Excluded from this release type: SessionId */
-
-/* Excluded from this release type: SessionSpaceCompressedId */
-
-/* Excluded from this release type: StableId */
-
-/* Excluded from this release type: SummarizeInternalFn */
+/**
+ * A compressed ID that has been normalized into "op space".
+ * Serialized/persisted structures (e.g. ops) should use op-space IDs as a performance optimization, as they require less normalizing when
+ * received by a remote client due to the fact that op space for a given compressor is session space for all other compressors.
+ * @alpha
+ */
+export declare type OpSpaceCompressedId = number & {
+    readonly OpNormalized: "9209432d-a959-4df7-b2ad-767ead4dbcae";
+};
+
+/**
+ * The serialized contents of an IdCompressor, suitable for persistence in a summary.
+ * @alpha
+ */
+export declare type SerializedIdCompressor = string & {
+    readonly _serializedIdCompressor: "8c73c57c-1cf4-4278-8915-6444cb4f6af5";
+};
+
+/**
+ * The serialized contents of an IdCompressor, suitable for persistence in a summary.
+ * @alpha
+ */
+export declare type SerializedIdCompressorWithNoSession = SerializedIdCompressor & {
+    readonly _noLocalState: "3aa2e1e8-cc28-4ea7-bc1a-a11dc3f26dfb";
+};
+
+/**
+ * The serialized contents of an IdCompressor, suitable for persistence in a summary.
+ * @alpha
+ */
+export declare type SerializedIdCompressorWithOngoingSession = SerializedIdCompressor & {
+    readonly _hasLocalState: "1281acae-6d14-47e7-bc92-71c8ee0819cb";
+};
+
+/**
+ * A StableId which is suitable for use as a session identifier
+ * @alpha
+ */
+export declare type SessionId = StableId & {
+    readonly SessionId: "4498f850-e14e-4be9-8db0-89ec00997e58";
+};
+
+/**
+ * A compressed ID that has been normalized into "session space" (see `IdCompressor` for more).
+ * Consumer-facing APIs and data structures should use session-space IDs as their lifetime and equality is stable and tied to
+ * the scope of the session (i.e. compressor) that produced them.
+ * @alpha
+ */
+export declare type SessionSpaceCompressedId = number & {
+    readonly SessionUnique: "cea55054-6b82-4cbf-ad19-1fa645ea3b3e";
+};
+
+/**
+ * A version 4, variant 1 uuid (https://datatracker.ietf.org/doc/html/rfc4122).
+ * A 128-bit Universally Unique IDentifier. Represented here
+ * with a string of the form xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx,
+ * where x is a lowercase hex digit.
+ * @alpha
+ */
+export declare type StableId = string & {
+    readonly StableId: "53172b0d-a3d5-41ea-bd75-b43839c97f5a";
+};
+
+/**
+ * @alpha
+ */
+export declare type SummarizeInternalFn = (fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext, incrementalSummaryContext?: IExperimentalIncrementalSummaryContext) => Promise<ISummarizeInternalResult>;
 
 /* Excluded from this release type: totalBlobSizePropertyName */
 
-/* Excluded from this release type: VisibilityState */
+/**
+ * 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 { }