@fluidframework/container-runtime 2.0.0-internal.7.3.0 → 2.0.0-internal.7.4.0

package/lib/container-runtime-untrimmed.d.ts

@@ -0,0 +1,1836 @@
+import { assertIsStableId } from '@fluidframework/id-compressor';
+import { AttachState } from '@fluidframework/container-definitions';
+import { ContainerWarning } from '@fluidframework/container-definitions';
+import { FluidDataStoreRegistryEntry } from '@fluidframework/runtime-definitions';
+import { FluidObject } from '@fluidframework/core-interfaces';
+import { FlushMode } from '@fluidframework/runtime-definitions';
+import { generateStableId } from '@fluidframework/id-compressor';
+import { IAudience } from '@fluidframework/container-definitions';
+import { IClientDetails } from '@fluidframework/protocol-definitions';
+import { IContainerContext } from '@fluidframework/container-definitions';
+import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
+import { IContainerRuntimeEvents } from '@fluidframework/container-runtime-definitions';
+import { ICriticalContainerError } from '@fluidframework/container-definitions';
+import { IDataStore } from '@fluidframework/runtime-definitions';
+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 { IFluidDataStoreContextDetached } from '@fluidframework/runtime-definitions';
+import { IFluidDataStoreRegistry } from '@fluidframework/runtime-definitions';
+import { IFluidHandle } from '@fluidframework/core-interfaces';
+import { IFluidHandleContext } from '@fluidframework/core-interfaces';
+import { IFluidRouter } from '@fluidframework/core-interfaces';
+import { IGarbageCollectionData } from '@fluidframework/runtime-definitions';
+import { IGetPendingLocalStateProps } from '@fluidframework/container-definitions';
+import type { IIdCompressor } from '@fluidframework/id-compressor';
+import type { IIdCompressorCore } from '@fluidframework/id-compressor';
+import { ILoader } from '@fluidframework/container-definitions';
+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';
+import { IRuntime } from '@fluidframework/container-definitions';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISignalMessage } from '@fluidframework/protocol-definitions';
+import { isStableId } from '@fluidframework/id-compressor';
+import { ISummaryAck } from '@fluidframework/protocol-definitions';
+import { ISummaryContent } from '@fluidframework/protocol-definitions';
+import { ISummaryNack } from '@fluidframework/protocol-definitions';
+import { ISummaryStats } from '@fluidframework/runtime-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ISummaryTreeWithStats } from '@fluidframework/runtime-definitions';
+import { ITelemetryContext } from '@fluidframework/runtime-definitions';
+import { ITelemetryLoggerExt } from '@fluidframework/telemetry-utils';
+import { MessageType } from '@fluidframework/protocol-definitions';
+import { NamedFluidDataStoreRegistryEntries } from '@fluidframework/runtime-definitions';
+import { TypedEventEmitter } from '@fluid-internal/client-utils';
+
+/**
+ * Legacy ID for the built-in AgentScheduler.  To minimize disruption while removing it, retaining this as a
+ * special-case for document dirty state.  Ultimately we should have no special-cases from the
+ * ContainerRuntime's perspective.
+ * @internal
+ */
+export declare const agentSchedulerId = "_scheduler";
+
+/**
+ * [IRRELEVANT IF throwOnInactiveLoad OPTION NOT SET] True if an inactive object should be returned without erroring
+ * @internal
+ */
+export declare const AllowInactiveRequestHeaderKey = "allowInactive";
+
+/** True if a tombstoned object should be returned without erroring
+ * @internal
+ */
+export declare const AllowTombstoneRequestHeaderKey = "allowTombstone";
+
+export { assertIsStableId }
+
+/**
+ * How should an older client handle an unrecognized remote op type?
+ *
+ * @internal
+ */
+export declare type CompatModeBehavior = 
+/** Ignore the op. It won't be persisted if this client summarizes */
+"Ignore"
+/** Fail processing immediately. (The container will close) */
+| "FailToProcess";
+
+/**
+ * Available compression algorithms for op compression.
+ * @alpha
+ */
+export declare enum CompressionAlgorithms {
+    lz4 = "lz4"
+}
+
+/**
+ * @internal
+ */
+export declare enum ContainerMessageType {
+    FluidDataStoreOp = "component",
+    Attach = "attach",
+    ChunkedOp = "chunkedOp",
+    BlobAttach = "blobAttach",
+    Rejoin = "rejoin",
+    Alias = "alias",
+    /**
+     * An op containing an IdRange of Ids allocated using the runtime's IdCompressor since
+     * the last allocation op was sent.
+     * See the [IdCompressor README](./id-compressor/README.md) for more details.
+     */
+    IdAllocation = "idAllocation",
+    /**
+     * Garbage collection specific op. This is sent by the summarizer client when GC runs. It's used to synchronize GC
+     * state across all clients.
+     */
+    GC = "GC"
+}
+
+/**
+ * Represents the runtime of the container. Contains helper functions/state of the container.
+ * It will define the store level mappings.
+ * @alpha
+ */
+export declare class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents & ISummarizerEvents> implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider, IProvideFluidHandleContext {
+    private readonly registry;
+    private readonly runtimeOptions;
+    private readonly containerScope;
+    readonly logger: ITelemetryLoggerExt;
+    private readonly _storage;
+    private readonly requestHandler?;
+    private readonly summaryConfiguration;
+    /**
+     * @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md
+     */
+    get IFluidRouter(): this;
+    /**
+     * @deprecated use loadRuntime instead.
+     * Load the stores from a snapshot and returns the runtime.
+     * @param context - Context of the container.
+     * @param registryEntries - Mapping to the stores.
+     * @param requestHandler - Request handlers for the container runtime
+     * @param runtimeOptions - Additional options to be passed to the runtime
+     * @param existing - (optional) When loading from an existing snapshot. Precedes context.existing if provided
+     * @param containerRuntimeCtor - (optional) Constructor to use to create the ContainerRuntime instance. This
+     * allows mixin classes to leverage this method to define their own async initializer.
+     */
+    static load(context: IContainerContext, registryEntries: NamedFluidDataStoreRegistryEntries, requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>, runtimeOptions?: IContainerRuntimeOptions, containerScope?: FluidObject, existing?: boolean, containerRuntimeCtor?: typeof ContainerRuntime): Promise<ContainerRuntime>;
+    /**
+     * Load the stores from a snapshot and returns the runtime.
+     * @param params - An object housing the runtime properties:
+     * - context - Context of the container.
+     * - registryEntries - Mapping from data store types to their corresponding factories.
+     * - existing - Pass 'true' if loading from an existing snapshot.
+     * - requestHandler - (optional) Request handler for the request() method of the container runtime.
+     * Only relevant for back-compat while we remove the request() method and move fully to entryPoint as the main pattern.
+     * - runtimeOptions - Additional options to be passed to the runtime
+     * - containerScope - runtime services provided with context
+     * - containerRuntimeCtor - Constructor to use to create the ContainerRuntime instance.
+     * This allows mixin classes to leverage this method to define their own async initializer.
+     * - provideEntryPoint - Promise that resolves to an object which will act as entryPoint for the Container.
+     * This object should provide all the functionality that the Container is expected to provide to the loader layer.
+     */
+    static loadRuntime(params: {
+        context: IContainerContext;
+        registryEntries: NamedFluidDataStoreRegistryEntries;
+        existing: boolean;
+        runtimeOptions?: IContainerRuntimeOptions;
+        containerScope?: FluidObject;
+        containerRuntimeCtor?: typeof ContainerRuntime;
+        /** @deprecated Will be removed in future major release. Migrate all usage of IFluidRouter to the "entryPoint" pattern. Refer to Removing-IFluidRouter.md */
+        requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>;
+        provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>;
+    }): Promise<ContainerRuntime>;
+    readonly options: ILoaderOptions;
+    private imminentClosure;
+    private readonly _getClientId;
+    get clientId(): string | undefined;
+    readonly clientDetails: IClientDetails;
+    get storage(): IDocumentStorageService;
+    private readonly submitFn;
+    /**
+     * Although current IContainerContext guarantees submitBatchFn, it is not available on older loaders.
+     */
+    private readonly submitBatchFn;
+    private readonly submitSummaryFn;
+    private readonly submitSignalFn;
+    readonly disposeFn: (error?: ICriticalContainerError) => void;
+    readonly closeFn: (error?: ICriticalContainerError) => void;
+    get flushMode(): FlushMode;
+    get scope(): FluidObject;
+    get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
+    private readonly _getAttachState;
+    get attachState(): AttachState;
+    idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+    get IFluidHandleContext(): IFluidHandleContext;
+    private readonly handleContext;
+    /**
+     * This is a proxy to the delta manager provided by the container context (innerDeltaManager). It restricts certain
+     * accesses such as sets "read-only" mode for the summarizer client. This is the default delta manager that should
+     * be used unless the innerDeltaManager is required.
+     */
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    /**
+     * The delta manager provided by the container context. By default, using the default delta manager (proxy)
+     * should be sufficient. This should be used only if necessary. For example, for validating and propagating connected
+     * events which requires access to the actual real only info, this is needed.
+     */
+    private readonly innerDeltaManager;
+    private readonly mc;
+    private readonly summarizerClientElection?;
+    /**
+     * summaryManager will only be created if this client is permitted to spawn a summarizing client
+     * It is created only by interactive client, i.e. summarizer client, as well as non-interactive bots
+     * do not create it (see SummarizerClientElection.clientDetailsPermitElection() for details)
+     */
+    private readonly summaryManager?;
+    private readonly summaryCollection;
+    private readonly summarizerNode;
+    private readonly maxConsecutiveReconnects;
+    private readonly defaultMaxConsecutiveReconnects;
+    private _orderSequentiallyCalls;
+    private readonly _flushMode;
+    private flushTaskExists;
+    private _connected;
+    private consecutiveReconnects;
+    /**
+     * Used to delay transition to "connected" state while we upload
+     * attachment blobs that were added while disconnected
+     */
+    private delayConnectClientId?;
+    private ensureNoDataModelChangesCalls;
+    /**
+     * Tracks the number of detected reentrant ops to report,
+     * in order to self-throttle the telemetry events.
+     *
+     * This should be removed as part of ADO:2322
+     */
+    private opReentryCallsToReport;
+    /**
+     * 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;
+    get connected(): boolean;
+    /** clientId of parent (non-summarizing) container that owns summarizer container */
+    get summarizerClientId(): string | undefined;
+    private _disposed;
+    get disposed(): boolean;
+    private dirtyContainer;
+    private emitDirtyDocumentEvent;
+    private readonly enableOpReentryCheck;
+    private readonly disableAttachReorder;
+    private readonly closeSummarizerDelayMs;
+    /**
+     * If true, summary generated is validate before uploading it to the server. With single commit summaries,
+     * summaries will be accepted once uploaded, so they should be validated before upload. However, this can
+     * currently be controlled via a feature flag as its a new functionality.
+     */
+    private readonly validateSummaryBeforeUpload;
+    private readonly defaultTelemetrySignalSampleCount;
+    private readonly _perfSignalData;
+    /**
+     * Summarizer is responsible for coordinating when to send generate and send summaries.
+     * It is the main entry point for summary work.
+     * It is created only by summarizing container (i.e. one with clientType === "summarizer")
+     */
+    private readonly _summarizer?;
+    private readonly scheduleManager;
+    private readonly blobManager;
+    private readonly pendingStateManager;
+    private readonly outbox;
+    private readonly garbageCollector;
+    private readonly dataStores;
+    private readonly remoteMessageProcessor;
+    /** The last message processed at the time of the last summary. */
+    private messageAtLastSummary;
+    private get summarizer();
+    private readonly summariesDisabled;
+    private isSummariesDisabled;
+    private readonly heuristicsDisabled;
+    private isHeuristicsDisabled;
+    private readonly maxOpsSinceLastSummary;
+    private getMaxOpsSinceLastSummary;
+    private readonly initialSummarizerDelayMs;
+    private getInitialSummarizerDelayMs;
+    private readonly createContainerMetadata;
+    /**
+     * The summary number of the next summary that will be generated for this container. This is incremented every time
+     * a summary is generated.
+     */
+    private nextSummaryNumber;
+    /** If false, loading or using a Tombstoned object should merely log, not fail */
+    get gcTombstoneEnforcementAllowed(): boolean;
+    /** If true, throw an error when a tombstone data store is used. */
+    get gcThrowOnTombstoneUsage(): boolean;
+    /**
+     * GUID to identify a document in telemetry
+     * ! Note: should not be used for anything other than telemetry and is not considered a stable GUID
+     */
+    private readonly telemetryDocumentId;
+    /**
+     * If true, the runtime has access to an IdCompressor
+     */
+    private readonly idCompressorEnabled;
+    /**
+     * Whether this client is the summarizer client itself (type is summarizerClientType)
+     */
+    private readonly isSummarizerClient;
+    /**
+     * The id of the version used to initially load this runtime, or undefined if it's newly created.
+     */
+    private readonly loadedFromVersionId;
+    /***/
+    protected constructor(context: IContainerContext, registry: IFluidDataStoreRegistry, metadata: IContainerRuntimeMetadata | undefined, electedSummarizerData: ISerializedElection | undefined, chunks: [string, string[]][], dataStoreAliasMap: [string, string][], runtimeOptions: Readonly<Required<IContainerRuntimeOptions>>, containerScope: FluidObject, logger: ITelemetryLoggerExt, existing: boolean, blobManagerSnapshot: IBlobManagerLoadInfo, _storage: IDocumentStorageService, idCompressor: (IIdCompressor & IIdCompressorCore) | undefined, provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>, requestHandler?: ((request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>) | undefined, summaryConfiguration?: ISummaryConfiguration);
+    /**
+     * Initializes the state from the base snapshot this container runtime loaded from.
+     */
+    private initializeBaseState;
+    dispose(error?: Error): void;
+    /**
+     * Notifies this object about the request made to the container.
+     * @param request - Request made to the handler.
+     * @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>;
+    /**
+     * Resolves URI representing handle
+     * @param request - Request made to the handler.
+     */
+    resolveHandle(request: IRequest): Promise<IResponse>;
+    /**
+     * {@inheritDoc @fluidframework/container-definitions#IRuntime.getEntryPoint}
+     */
+    getEntryPoint(): Promise<FluidObject>;
+    private readonly entryPoint;
+    private internalId;
+    private getDataStoreFromRequest;
+    /** Adds the container's metadata to the given summary tree. */
+    private addMetadataToSummary;
+    protected addContainerStateToSummary(summaryTree: ISummaryTreeWithStats, fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): void;
+    private shouldContinueReconnecting;
+    private resetReconnectCount;
+    private replayPendingStates;
+    /**
+     * Parse an op's type and actual content from given serialized content
+     * ! Note: this format needs to be in-line with what is set in the "ContainerRuntime.submit(...)" method
+     */
+    private parseLocalOpContent;
+    private applyStashedOp;
+    setConnectionState(connected: boolean, clientId?: string): void;
+    private setConnectionStateCore;
+    notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
+    process(messageArg: ISequencedDocumentMessage, local: boolean): void;
+    private _processedClientSequenceNumber;
+    /**
+     * Direct the message to the correct subsystem for processing, and implement other side effects
+     */
+    private processCore;
+    /**
+     * Assuming the given message is also a TypedContainerRuntimeMessage,
+     * checks its type and dispatches the message to the appropriate handler in the runtime.
+     * Throws a DataProcessingError if the message looks like but doesn't conform to a known TypedContainerRuntimeMessage type.
+     */
+    private validateAndProcessRuntimeMessage;
+    /**
+     * Emits the Signal event and update the perf signal data.
+     * @param clientSignalSequenceNumber - is the client signal sequence number to be uploaded.
+     */
+    private sendSignalTelemetryEvent;
+    processSignal(message: ISignalMessage, local: boolean): void;
+    /**
+     * Returns the runtime of the data store.
+     * @param id - Id supplied during creating the data store.
+     * @param wait - True if you want to wait for it.
+     * @deprecated Use getAliasedDataStoreEntryPoint instead to get an aliased data store's entry point.
+     */
+    getRootDataStore(id: string, wait?: boolean): Promise<IFluidRouter>;
+    private getRootDataStoreChannel;
+    /**
+     * Flush the pending ops manually.
+     * This method is expected to be called at the end of a batch.
+     */
+    private flush;
+    orderSequentially<T>(callback: () => T): T;
+    /**
+     * Returns the aliased data store's entryPoint, given the alias.
+     * @param alias - The alias for the data store.
+     * @returns The data store's entry point ({@link @fluidframework/core-interfaces#IFluidHandle}) if it exists and is aliased.
+     * Returns undefined if no data store has been assigned the given alias.
+     */
+    getAliasedDataStoreEntryPoint(alias: string): Promise<IFluidHandle<FluidObject> | undefined>;
+    createDetachedRootDataStore(pkg: Readonly<string[]>, rootDataStoreId: string): IFluidDataStoreContextDetached;
+    createDetachedDataStore(pkg: Readonly<string[]>): IFluidDataStoreContextDetached;
+    createDataStore(pkg: string | string[]): Promise<IDataStore>;
+    /**
+     * @deprecated 0.16 Issue #1537, #3631
+     */
+    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
+    private canSendOps;
+    /**
+     * Are we in the middle of batching ops together?
+     */
+    private currentlyBatching;
+    private readonly _quorum;
+    getQuorum(): IQuorumClients;
+    private readonly _audience;
+    getAudience(): IAudience;
+    /**
+     * Returns true of container is dirty, i.e. there are some pending local changes that
+     * either were not sent out to delta stream or were not yet acknowledged.
+     */
+    get isDirty(): boolean;
+    private isContainerMessageDirtyable;
+    private createNewSignalEnvelope;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    submitDataStoreSignal(address: string, type: string, content: any, targetClientId?: string): void;
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    /**
+     * Create a summary. Used when attaching or serializing a detached container.
+     *
+     * @param blobRedirectTable - A table passed during the attach process. While detached, blob upload is supported
+     * using IDs generated locally. After attach, these IDs cannot be used, so this table maps the old local IDs to the
+     * new storage IDs so requests can be redirected.
+     * @param telemetryContext - summary data passed through the layers for telemetry purposes
+     */
+    createSummary(blobRedirectTable?: Map<string, string>, telemetryContext?: ITelemetryContext): ISummaryTree;
+    readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>;
+    private summarizeInternal;
+    /**
+     * Returns a summary of the runtime at the current sequence number.
+     */
+    summarize(options: {
+        /** True to generate the full tree with no handle reuse optimizations; defaults to false */
+        fullTree?: boolean;
+        /** True to track the state for this summary in the SummarizerNodes; defaults to true */
+        trackState?: boolean;
+        /** Logger to use for correlated summary events */
+        summaryLogger?: ITelemetryLoggerExt;
+        /** True to run garbage collection before summarizing; defaults to true */
+        runGC?: boolean;
+        /** True to generate full GC data */
+        fullGC?: boolean;
+        /** True to run GC sweep phase after the mark phase */
+        runSweep?: boolean;
+    }): Promise<ISummaryTreeWithStats>;
+    /**
+     * Before GC runs, called by the garbage collector to update any pending GC state. This is mainly used to notify
+     * the garbage collector of references detected since the last GC run. Most references are notified immediately
+     * but there can be some for which async operation is required (such as detecting new root data stores).
+     * @see IGarbageCollectionRuntime.updateStateBeforeGC
+     */
+    updateStateBeforeGC(): Promise<void>;
+    private getGCDataInternal;
+    /**
+     * Generates and returns the GC data for this container.
+     * @param fullGC - true to bypass optimizations and force full generation of GC data.
+     * @see IGarbageCollectionRuntime.getGCData
+     */
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    /**
+     * After GC has run, called to notify this container's nodes of routes that are used in it.
+     * @param usedRoutes - The routes that are used in all nodes in this Container.
+     * @see IGarbageCollectionRuntime.updateUsedRoutes
+     */
+    updateUsedRoutes(usedRoutes: readonly string[]): void;
+    /**
+     * This is called to update objects whose routes are unused.
+     * @param unusedRoutes - Data store and attachment blob routes that are unused in this Container.
+     */
+    updateUnusedRoutes(unusedRoutes: readonly string[]): void;
+    /**
+     * @deprecated Replaced by deleteSweepReadyNodes.
+     */
+    deleteUnusedNodes(unusedRoutes: readonly string[]): string[];
+    /**
+     * After GC has run and identified nodes that are sweep ready, this is called to delete the sweep ready nodes.
+     * @param sweepReadyRoutes - The routes of nodes that are sweep ready and should be deleted.
+     * @returns The routes of nodes that were deleted.
+     */
+    deleteSweepReadyNodes(sweepReadyRoutes: readonly string[]): readonly string[];
+    /**
+     * This is called to update objects that are tombstones.
+     * @param tombstonedRoutes - Data store and attachment blob routes that are tombstones in this Container.
+     */
+    updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
+    /**
+     * Returns a server generated referenced timestamp to be used to track unreferenced nodes by GC.
+     */
+    getCurrentReferenceTimestampMs(): number | undefined;
+    /**
+     * Returns the type of the GC node. Currently, there are nodes that belong to the root ("/"), data stores or
+     * blob manager.
+     */
+    getNodeType(nodePath: string): GCNodeType;
+    /**
+     * Called by GC to retrieve the package path of the node with the given path. The node should belong to a
+     * data store or an attachment blob.
+     */
+    getGCNodePackagePath(nodePath: string): Promise<readonly string[] | undefined>;
+    /**
+     * Returns whether a given path is for attachment blobs that are in the format - "/BlobManager.basePath/...".
+     */
+    private isBlobPath;
+    /**
+     * From a given list of routes, separate and return routes that belong to blob manager and data stores.
+     * @param routes - A list of routes that can belong to data stores or blob manager.
+     * @returns Two route lists - One that contains routes for blob manager and another one that contains routes
+     * for data stores.
+     */
+    private getDataStoreAndBlobManagerRoutes;
+    /**
+     * Runs garbage collection and updates the reference / used state of the nodes in the container.
+     * @returns the statistics of the garbage collection run; undefined if GC did not run.
+     */
+    collectGarbage(options: {
+        /** Logger to use for logging GC events */
+        logger?: ITelemetryLoggerExt;
+        /** True to run GC sweep phase after the mark phase */
+        runSweep?: boolean;
+        /** True to generate full GC data */
+        fullGC?: boolean;
+    }, telemetryContext?: ITelemetryContext): Promise<IGCStats | undefined>;
+    /**
+     * 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;
+    /**
+     * Generates the summary tree, uploads it to storage, and then submits the summarize op.
+     * This is intended to be called by the summarizer, since it is the implementation of
+     * ISummarizerInternalsProvider.submitSummary.
+     * It takes care of state management at the container level, including pausing inbound
+     * op processing, updating SummarizerNode state tracking, and garbage collection.
+     * @param options - options controlling how the summary is generated or submitted
+     */
+    submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
+    /**
+     * This helper is called during summarization. If the container is dirty, it will return a failed summarize result
+     * (IBaseSummarizeResult) unless this is the final summarize attempt and SkipFailingIncorrectSummary option is set.
+     * @param logger - The logger to be used for sending telemetry.
+     * @param referenceSequenceNumber - The reference sequence number of the summary attempt.
+     * @param minimumSequenceNumber - The minimum sequence number of the summary attempt.
+     * @param finalAttempt - Whether this is the final summary attempt.
+     * @param beforeSummaryGeneration - Whether this is called before summary generation or after.
+     * @returns failed summarize result (IBaseSummarizeResult) if summary should be failed, undefined otherwise.
+     */
+    private shouldFailSummaryOnPendingOps;
+    private get pendingMessagesCount();
+    private hasPendingMessages;
+    private updateDocumentDirtyState;
+    submitDataStoreOp(id: string, contents: any, localOpMetadata?: unknown): void;
+    submitDataStoreAliasOp(contents: any, localOpMetadata: unknown): void;
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+    private maybeSubmitIdAllocationOp;
+    private submit;
+    private scheduleFlush;
+    private submitSummaryMessage;
+    /**
+     * Throw an error if the runtime is closed.  Methods that are expected to potentially
+     * be called after dispose due to asynchrony should not call this.
+     */
+    private verifyNotClosed;
+    private verifyCanSubmitOps;
+    private reSubmitBatch;
+    private reSubmit;
+    /**
+     * Finds the right store and asks it to resubmit the message. This typically happens when we
+     * reconnect and there are pending messages.
+     * ! Note: successfully resubmitting an op that has been successfully sequenced is not possible due to checks in the ConnectionStateHandler (Loader layer)
+     * @param message - The original LocalContainerRuntimeMessage.
+     * @param localOpMetadata - The local metadata associated with the original message.
+     */
+    private reSubmitCore;
+    private rollback;
+    /** Implementation of ISummarizerInternalsProvider.refreshLatestSummaryAck */
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
+    /**
+     * Fetches the latest snapshot from storage to refresh the cache as a performance optimization and closes the
+     * summarizer to reload from new state.
+     * @param summaryLogger - logger to use when fetching snapshot from storage
+     * @returns a generic summarization error
+     */
+    private prefetchLatestSummaryThenClose;
+    private closeStaleSummarizer;
+    /**
+     * Downloads the latest snapshot from storage.
+     * By default, it also closes the container after downloading the snapshot. However, this may be
+     * overridden via options.
+     */
+    private fetchLatestSnapshotFromStorage;
+    notifyAttaching(): void;
+    getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown>;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    /**
+     * Forms a function that will create and retrieve a Summarizer.
+     */
+    private formCreateSummarizerFn;
+    private validateSummaryHeuristicConfiguration;
+    private get groupedBatchingEnabled();
+}
+
+/**
+ * The unpacked runtime message / details to be handled or dispatched by the ContainerRuntime
+ *
+ * IMPORTANT: when creating one to be serialized, set the properties in the order they appear here.
+ * This way stringified values can be compared.
+ *
+ * @deprecated this is an internal type which should not be used outside of the package.
+ * Internally, it is superseded by `TypedContainerRuntimeMessage`.
+ *
+ * @internal
+ */
+export declare interface ContainerRuntimeMessage {
+    /** Type of the op, within the ContainerRuntime's domain */
+    type: ContainerMessageType;
+    /** Domain-specific contents, interpreted according to the type */
+    contents: any;
+    /** Info describing how to handle this op in case the type is unrecognized (default: fail to process) */
+    compatDetails?: IContainerRuntimeMessageCompatDetails;
+}
+
+/**
+ * @internal
+ */
+export declare const DefaultSummaryConfiguration: ISummaryConfiguration;
+
+/**
+ * @alpha
+ */
+export declare type EnqueueSummarizeResult = (ISummarizeResults & {
+    /**
+     * Indicates that another summarize attempt is not already enqueued,
+     * and this attempt has been enqueued.
+     */
+    readonly alreadyEnqueued?: undefined;
+}) | (ISummarizeResults & {
+    /** Indicates that another summarize attempt was already enqueued. */
+    readonly alreadyEnqueued: true;
+    /**
+     * Indicates that the other enqueued summarize attempt was abandoned,
+     * and this attempt has been enqueued enqueued.
+     */
+    readonly overridden: true;
+}) | {
+    /** Indicates that another summarize attempt was already enqueued. */
+    readonly alreadyEnqueued: true;
+    /**
+     * Indicates that the other enqueued summarize attempt remains enqueued,
+     * and this attempt has not been enqueued.
+     */
+    readonly overridden?: undefined;
+};
+
+/**
+ * @internal
+ */
+export declare class FluidDataStoreRegistry implements IFluidDataStoreRegistry {
+    private readonly map;
+    get IFluidDataStoreRegistry(): this;
+    constructor(namedEntries: NamedFluidDataStoreRegistryEntries);
+    get(name: string): Promise<FluidDataStoreRegistryEntry | undefined>;
+}
+
+/**
+ * @see IGCMetadata.gcFeatureMatrix and @see gcGenerationOptionName
+ * @alpha
+ */
+export declare type GCFeatureMatrix = {
+    /**
+     * The GC Generation value in effect when this file was created.
+     * Gives a way for an app to disqualify old files from GC Sweep.
+     * Provided via Container Runtime Options.
+     */
+    gcGeneration?: number;
+    /** Deprecated property from legacy type. Will not be set concurrently with gcGeneration */
+    tombstoneGeneration?: undefined;
+} | {
+    /**
+     * The Tombstone Generation value in effect when this file was created.
+     * Legacy - new containers would get gcGeneration instead (if anything)
+     */
+    tombstoneGeneration: number;
+};
+
+/**
+ * The types of GC nodes in the GC reference graph.
+ * @alpha
+ */
+export declare const GCNodeType: {
+    DataStore: string;
+    SubDataStore: string;
+    Blob: string;
+    Other: string;
+};
+
+/**
+ * @alpha
+ */
+export declare type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
+
+/**
+ * @alpha
+ */
+export declare type GCVersion = number;
+
+export { generateStableId }
+
+/**
+ * A single summary which has already been acked by the server.
+ * @internal
+ */
+export declare interface IAckedSummary {
+    readonly summaryOp: ISummaryOpMessage;
+    readonly summaryAck: ISummaryAckMessage;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IAckSummaryResult {
+    readonly summaryAckOp: ISummaryAckMessage;
+    readonly ackNackDuration: number;
+}
+
+/**
+ * Base results for all submitSummary attempts.
+ * @alpha
+ */
+export declare interface IBaseSummarizeResult {
+    readonly stage: "base";
+    /** Error object related to failed summarize attempt. */
+    readonly error: any;
+    /** Reference sequence number as of the generate summary attempt. */
+    readonly referenceSequenceNumber: number;
+    readonly minimumSequenceNumber: number;
+}
+
+/**
+ * Information from a snapshot needed to load BlobManager
+ * @alpha
+ */
+export declare interface IBlobManagerLoadInfo {
+    ids?: string[];
+    redirectTable?: [string, string][];
+}
+
+/**
+ * @alpha
+ */
+export declare interface IBroadcastSummaryResult {
+    readonly summarizeOp: ISummaryOpMessage;
+    readonly broadcastDuration: number;
+}
+
+/**
+ * Similar to AbortController, but using promise instead of events
+ * @internal
+ */
+export declare interface ICancellableSummarizerController extends ISummaryCancellationToken {
+    stop(reason: SummarizerStopReason): void;
+}
+
+/**
+ * Similar to AbortSignal, but using promise instead of events
+ * @param T - cancellation reason type
+ * @alpha
+ */
+export declare interface ICancellationToken<T> {
+    /** Tells if this cancellable token is cancelled */
+    readonly cancelled: boolean;
+    /**
+     * Promise that gets fulfilled when this cancellable token is cancelled
+     * @returns reason of cancellation
+     */
+    readonly waitCancelled: Promise<T>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IChunkedOp {
+    chunkId: number;
+    totalChunks: number;
+    contents: string;
+    originalType: MessageType | ContainerMessageType;
+    originalMetadata?: Record<string, unknown>;
+    originalCompression?: string;
+}
+
+/**
+ * Watches summaries created by a specific client.
+ * @internal
+ */
+export declare interface IClientSummaryWatcher extends IDisposable {
+    watchSummary(clientSequenceNumber: number): ISummary;
+    waitFlushed(): Promise<IAckedSummary | undefined>;
+}
+
+/**
+ * Options for op compression.
+ * @alpha
+ */
+export declare interface ICompressionRuntimeOptions {
+    /**
+     * The value the batch's content size must exceed for the batch to be compressed.
+     * By default the value is 600 * 1024 = 614400 bytes. If the value is set to `Infinity`, compression will be disabled.
+     */
+    readonly minimumBatchSizeInBytes: number;
+    /**
+     * The compression algorithm that will be used to compress the op.
+     * By default the value is `lz4` which is the only compression algorithm currently supported.
+     */
+    readonly compressionAlgorithm: CompressionAlgorithms;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IConnectableRuntime {
+    readonly disposed: boolean;
+    readonly connected: boolean;
+    readonly clientId: string | undefined;
+    once(event: "connected" | "disconnected" | "dispose", listener: () => void): this;
+}
+
+/**
+ * All the info an older client would need to know how to handle an unrecognized remote op type
+ *
+ * @internal
+ */
+export declare interface IContainerRuntimeMessageCompatDetails {
+    /** How should an older client handle an unrecognized remote op type? */
+    behavior: CompatModeBehavior;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGCMetadata {
+    readonly summaryFormatVersion: 1;
+    /** The last message processed at the time of summary. Only primitive property types are added to the summary. */
+    readonly message: ISummaryMetadataMessage | undefined;
+    /** True if channels are not isolated in .channels subtrees, otherwise isolated. */
+    readonly disableIsolatedChannels?: true;
+    /** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
+    readonly summaryNumber?: number;
+    /** GUID to identify a document in telemetry */
+    readonly telemetryDocumentId?: string;
+    /** True if the runtime IdCompressor is enabled */
+    readonly idCompressorEnabled?: boolean;
+}
+
+/**
+ * Options for container runtime.
+ * @alpha
+ */
+export declare interface IContainerRuntimeOptions {
+    readonly summaryOptions?: ISummaryRuntimeOptions;
+    readonly gcOptions?: IGCRuntimeOptions;
+    /**
+     * Affects the behavior while loading the runtime when the data verification check which
+     * compares the DeltaManager sequence number (obtained from protocol in summary) to the
+     * runtime sequence number (obtained from runtime metadata in summary) finds a mismatch.
+     * 1. "close" (default) will close the container with an assertion.
+     * 2. "log" will log an error event to telemetry, but still continue to load.
+     * 3. "bypass" will skip the check entirely. This is not recommended.
+     */
+    readonly loadSequenceNumberVerification?: "close" | "log" | "bypass";
+    /**
+     * Sets the flush mode for the runtime. In Immediate flush mode the runtime will immediately
+     * send all operations to the driver layer, while in TurnBased the operations will be buffered
+     * and then sent them as a single batch at the end of the turn.
+     * By default, flush mode is TurnBased.
+     */
+    readonly flushMode?: FlushMode;
+    /**
+     * Enables the runtime to compress ops. See {@link ICompressionRuntimeOptions}.
+     */
+    readonly compressionOptions?: ICompressionRuntimeOptions;
+    /**
+     * If specified, when in FlushMode.TurnBased, if the size of the ops between JS turns exceeds this value,
+     * an error will be thrown and the container will close.
+     *
+     * If unspecified, the limit is 950 * 1024.
+     *
+     * 'Infinity' will disable any limit.
+     *
+     * @experimental This config should be driven by the connection with the service and will be moved in the future.
+     */
+    readonly maxBatchSizeInBytes?: number;
+    /**
+     * If the op payload needs to be chunked in order to work around the maximum size of the batch, this value represents
+     * how large the individual chunks will be. This is only supported when compression is enabled. If after compression, the
+     * batch content size exceeds this value, it will be chunked into smaller ops of this exact size.
+     *
+     * This value is a trade-off between having many small chunks vs fewer larger chunks and by default, the runtime is configured to use
+     * 200 * 1024 = 204800 bytes. This default value ensures that no compressed payload's content is able to exceed {@link IContainerRuntimeOptions.maxBatchSizeInBytes}
+     * regardless of the overhead of an individual op.
+     *
+     * Any value of `chunkSizeInBytes` exceeding {@link IContainerRuntimeOptions.maxBatchSizeInBytes} will disable this feature, therefore if a compressed batch's content
+     * size exceeds {@link IContainerRuntimeOptions.maxBatchSizeInBytes} after compression, the container will close with an instance of `GenericError` with
+     * the `BatchTooLarge` message.
+     */
+    readonly chunkSizeInBytes?: number;
+    /**
+     * Enable the IdCompressor in the runtime.
+     * @experimental Not ready for use.
+     */
+    readonly enableRuntimeIdCompressor?: boolean;
+    /**
+     * If enabled, the runtime will block all attempts to send an op inside the
+     * {@link ContainerRuntime#ensureNoDataModelChanges} callback. The callback is used by
+     * {@link @fluidframework/shared-object-base#SharedObjectCore} for event handlers so enabling this
+     * will disallow modifying DDSes while handling DDS events.
+     *
+     * By default, the feature is disabled. If enabled from options, the `Fluid.ContainerRuntime.DisableOpReentryCheck`
+     * can be used to disable it at runtime.
+     */
+    readonly enableOpReentryCheck?: boolean;
+    /**
+     * If enabled, the runtime will group messages within a batch into a single
+     * message to be sent to the service.
+     * The grouping an ungrouping of such messages is handled by the "OpGroupingManager".
+     *
+     * By default, the feature is disabled. If enabled from options, the `Fluid.ContainerRuntime.DisableGroupedBatching`
+     * flag can be used to disable it at runtime.
+     *
+     * @experimental Not ready for use.
+     */
+    readonly enableGroupedBatching?: boolean;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ICreateContainerMetadata {
+    /** Runtime version of the container when it was first created */
+    createContainerRuntimeVersion?: string;
+    /** Timestamp of the container when it was first created */
+    createContainerTimestamp?: number;
+}
+
+/**
+ * Options to use when enqueueing a summarize attempt.
+ * @alpha
+ */
+export declare interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
+    /** If specified, The summarize attempt will not occur until after this sequence number. */
+    readonly afterSequenceNumber?: number;
+    /**
+     * True to override the existing enqueued summarize attempt if there is one.
+     * This will guarantee that this attempt gets enqueued. If override is false,
+     * than an existing enqueued summarize attempt will block a new one from being
+     * enqueued. There can only be one enqueued at a time. Defaults to false.
+     */
+    readonly override?: boolean;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IGCMetadata {
+    /**
+     * The version of the GC code that was run to generate the GC data that is written in the summary.
+     * If the persisted value doesn't match the current value in the code, saved GC data will be discarded and regenerated from scratch.
+     * Also, used to determine whether GC is enabled for this container or not:
+     * - A value of 0 or undefined means GC is disabled.
+     * - A value greater than 0 means GC is enabled.
+     */
+    readonly gcFeature?: GCVersion;
+    /**
+     * A collection of different numerical "Generations" for different features,
+     * used to determine feature availability over time.
+     * This info may come from multiple sources (FF code, config service, app via Container Runtime Options),
+     * and pertains to aspects of the document that may be fixed for its lifetime.
+     *
+     * For each dimension, if the persisted value doesn't match the currently provided value,
+     * then this file does not support the corresponding feature as currently implemented.
+     *
+     * Guidance is that if no value is provided at runtime, it should result in the current default behavior.
+     */
+    readonly gcFeatureMatrix?: GCFeatureMatrix;
+    /**
+     * Tells whether the GC sweep phase is enabled for this container.
+     * - True means sweep phase is enabled.
+     * - False means sweep phase is disabled. If GC is disabled as per gcFeature, sweep is also disabled.
+     *
+     * @deprecated use GCFeatureMatrix.gcGeneration instead. @see GCFeatureMatrix.gcGeneration
+     */
+    readonly sweepEnabled?: boolean;
+    /** If this is present, the session for this container will expire after this time and the container will close */
+    readonly sessionExpiryTimeoutMs?: number;
+    /** How long to wait after an object is unreferenced before deleting it via GC Sweep */
+    readonly sweepTimeoutMs?: number;
+}
+
+/**
+ * @alpha
+ */
+export declare interface IGCRuntimeOptions {
+    /**
+     * Flag that if true, will enable running garbage collection (GC) for a new container.
+     *
+     * GC has mark phase and sweep phase. In mark phase, unreferenced objects are identified
+     * and marked as such in the summary. This option enables the mark phase.
+     * In sweep phase, unreferenced objects are eventually deleted from the container if they meet certain conditions.
+     * Sweep phase can be enabled using the "enableGCSweep" option.
+     *
+     * Note: This setting is persisted in the container's summary and cannot be changed.
+     */
+    gcAllowed?: boolean;
+    /**
+     * Flag that if true, will disable garbage collection for the session.
+     * Can be used to disable running GC on containers where it is allowed via the gcAllowed option.
+     */
+    disableGC?: boolean;
+    /**
+     * Flag that if true, will enable the full Sweep Phase of garbage collection for this session,
+     * where Tombstoned objects are permanently deleted from the container.
+     *
+     * IMPORTANT: This only applies if this document is allowed to run Sweep Phase.
+     *
+     * Current default behavior is for Sweep Phase not to delete Tombstoned objects,
+     * but merely to prevent them from being loaded.
+     */
+    enableGCSweep?: true;
+    /**
+     * Flag that will bypass optimizations and generate GC data for all nodes irrespective of whether a node
+     * changed or not.
+     */
+    runFullGC?: boolean;
+    /**
+     * Maximum session duration for a new container. If not present, a default value will be used.
+     *
+     * Note: This setting is persisted in the container's summary and cannot be changed.
+     */
+    sessionExpiryTimeoutMs?: number;
+    /**
+     * Delay between when Tombstone should run and when the object should be deleted.
+     * This grace period gives a chance to intervene to recover if needed, before Sweep deletes the object.
+     * If not present, a default (non-zero) value will be used.
+     */
+    sweepGracePeriodMs?: number;
+    /**
+     * Allows additional GC options to be passed.
+     */
+    [key: string]: any;
+}
+
+/**
+ * The statistics of the system state after a garbage collection run.
+ * @alpha
+ */
+export declare interface IGCStats extends IMarkPhaseStats, ISweepPhaseStats {
+}
+
+/**
+ * In addition to the normal summary tree + stats, this contains additional stats
+ * only relevant at the root of the tree.
+ * @alpha
+ */
+export declare interface IGeneratedSummaryStats extends ISummaryStats {
+    /** The total number of data stores in the container. */
+    readonly dataStoreCount: number;
+    /** The number of data stores that were summarized in this summary. */
+    readonly summarizedDataStoreCount: number;
+    /** The number of data stores whose GC reference state was updated in this summary. */
+    readonly gcStateUpdatedDataStoreCount?: number;
+    /** The size of the gc blobs in this summary. */
+    readonly gcTotalBlobsSize?: number;
+    /** The number of gc blobs in this summary. */
+    readonly gcBlobNodeCount?: number;
+    /** The summary number for a container's summary. Incremented on summaries throughout its lifetime. */
+    readonly summaryNumber: number;
+}
+
+/**
+ * Results of submitSummary after generating the summary tree.
+ * @alpha
+ */
+export declare interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeResult, "stage"> {
+    readonly stage: "generate";
+    /** Generated summary tree. */
+    readonly summaryTree: ISummaryTree;
+    /** Stats for generated summary tree. */
+    readonly summaryStats: IGeneratedSummaryStats;
+    /** Time it took to generate the summary tree and stats. */
+    readonly generateDuration: number;
+    /** True if the full tree regeneration with no handle reuse optimizations was forced. */
+    readonly forcedFullTree: boolean;
+}
+
+/**
+ * The statistics of the system state after a garbage collection mark phase run.
+ * @alpha
+ */
+export declare interface IMarkPhaseStats {
+    /** The number of nodes in the container. */
+    nodeCount: number;
+    /** The number of data stores in the container. */
+    dataStoreCount: number;
+    /** The number of attachment blobs in the container. */
+    attachmentBlobCount: number;
+    /** The number of unreferenced nodes in the container. */
+    unrefNodeCount: number;
+    /** The number of unreferenced data stores in the container. */
+    unrefDataStoreCount: number;
+    /** The number of unreferenced attachment blobs in the container. */
+    unrefAttachmentBlobCount: number;
+    /** The number of nodes whose reference state updated since last GC run. */
+    updatedNodeCount: number;
+    /** The number of data stores whose reference state updated since last GC run. */
+    updatedDataStoreCount: number;
+    /** The number of attachment blobs whose reference state updated since last GC run. */
+    updatedAttachmentBlobCount: number;
+}
+
+/**
+ * @alpha
+ */
+export declare interface INackSummaryResult extends IRetriableFailureResult {
+    readonly summaryNackOp: ISummaryNackMessage;
+    readonly ackNackDuration: number;
+}
+
+/**
+ * Inactive error responses will have this header set to true
+ * @internal
+ */
+export declare const InactiveResponseHeaderKey = "isInactive";
+
+/**
+ * @alpha
+ */
+export declare interface IOnDemandSummarizeOptions extends ISummarizeOptions {
+    /** Reason for generating summary. */
+    readonly reason: string;
+}
+
+/**
+ * Data required to update internal tracking state after receiving a Summary Ack.
+ * @alpha
+ */
+export declare interface IRefreshSummaryAckOptions {
+    /** Handle from the ack's summary op. */
+    readonly proposalHandle: string | undefined;
+    /** Handle from the summary ack just received */
+    readonly ackHandle: string;
+    /** Reference sequence number from the ack's summary op */
+    readonly summaryRefSeq: number;
+    /** Telemetry logger to which telemetry events will be forwarded. */
+    readonly summaryLogger: ITelemetryLoggerExt;
+}
+
+/**
+ * Type for summarization failures that are retriable.
+ * @alpha
+ */
+export declare interface IRetriableFailureResult {
+    readonly retryAfterSeconds?: number;
+}
+
+/**
+ * Serialized state of IOrderedClientElection.
+ * @alpha
+ */
+export declare interface ISerializedElection {
+    /** Sequence number at the time of the latest election. */
+    readonly electionSequenceNumber: number;
+    /**
+     * Most recently elected client id. This is either:
+     *
+     * 1. the interactive elected parent client, in which case electedClientId === electedParentId,
+     * and the SummaryManager on the elected client will spawn a summarizer client, or
+     *
+     * 2. the non-interactive summarizer client itself.
+     */
+    readonly electedClientId: string | undefined;
+    /** Most recently elected parent client id. This is always an interactive client. */
+    readonly electedParentId: string | undefined;
+}
+
+/**
+ * @deprecated please use version in driver-utils
+ * @internal
+ */
+export declare function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
+
+export { isStableId }
+
+/**
+ * Results of submitSummary after submitting the summarize op.
+ * @alpha
+ */
+export declare interface ISubmitSummaryOpResult extends Omit<IUploadSummaryResult, "stage" | "error"> {
+    readonly stage: "submit";
+    /** The client sequence number of the summarize op submitted for the summary. */
+    readonly clientSequenceNumber: number;
+    /** Time it took to submit the summarize op to the broadcasting service. */
+    readonly submitOpDuration: number;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISubmitSummaryOptions extends ISummarizeOptions {
+    /** Logger to use for correlated summary events */
+    readonly summaryLogger: ITelemetryLoggerExt;
+    /** Tells when summary process should be cancelled */
+    readonly cancellationToken: ISummaryCancellationToken;
+    /** Summarization may be attempted multiple times. This tells whether this is the final summarization attempt. */
+    readonly finalAttempt?: boolean;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizeEventProps {
+    result: "success" | "failure" | "canceled";
+    currentAttempt: number;
+    maxAttempts: number;
+    error?: any;
+}
+
+/**
+ * Options affecting summarize behavior.
+ * @alpha
+ */
+export declare interface ISummarizeOptions {
+    /** True to generate the full tree with no handle reuse optimizations; defaults to false */
+    readonly fullTree?: boolean;
+    /**
+     * True to ask the server what the latest summary is first; defaults to false
+     *
+     * @deprecated Summarize will not refresh latest snapshot state anymore. Instead it updates the cache and closes.
+     * It's expected a new summarizer client will be created, likely by the same parent.
+     */
+    readonly refreshLatestAck?: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISummarizer extends IEventProvider<ISummarizerEvents> {
+    /**
+     * Allows {@link ISummarizer} to be used with our {@link @fluidframework/core-interfaces#FluidObject} pattern.
+     */
+    readonly ISummarizer?: ISummarizer;
+    stop(reason: SummarizerStopReason): void;
+    close(): void;
+    run(onBehalfOf: string, disableHeuristics?: boolean): Promise<SummarizerStopReason>;
+    /**
+     * Attempts to generate a summary on demand. If already running, takes no action.
+     * @param options - options controlling the summarize attempt
+     * @returns an alreadyRunning promise if a summarize attempt is already in progress,
+     * which will resolve when the current attempt completes. At that point caller can
+     * decide to try again or not. Otherwise, it will return an object containing promises
+     * that resolve as the summarize attempt progresses. They will resolve with success
+     * false if a failure is encountered.
+     */
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    /**
+     * Enqueue an attempt to summarize after the specified sequence number.
+     * If afterSequenceNumber is provided, the summarize attempt is "enqueued"
+     * to run once an eligible op comes in with sequenceNumber \>= afterSequenceNumber.
+     * @param options - options controlling the summarize attempt
+     * @returns an object containing an alreadyEnqueued flag to indicate if another
+     * summarize attempt has already been enqueued. It also may contain an overridden flag
+     * when alreadyEnqueued is true, that indicates whether this attempt forced the
+     * previous attempt to abort. If this attempt becomes enqueued, it returns an object
+     * containing promises that resolve as the summarize attempt progresses. They will
+     * resolve with success false if a failure is encountered.
+     */
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizeResults {
+    /** Resolves when we generate, upload, and submit the summary. */
+    readonly summarySubmitted: Promise<SummarizeResultPart<SubmitSummaryResult, SubmitSummaryFailureData>>;
+    /** Resolves when we observe our summarize op broadcast. */
+    readonly summaryOpBroadcasted: Promise<SummarizeResultPart<IBroadcastSummaryResult>>;
+    /** Resolves when we receive a summaryAck or summaryNack. */
+    readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerEvents extends IEvent {
+    (event: "summarize", listener: (props: ISummarizeEventProps) => void): any;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerInternalsProvider {
+    /** Encapsulates the work to walk the internals of the running container to generate a summary */
+    submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
+    /** Callback whenever a new SummaryAck is received, to update internal tracking state */
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummarizerRuntime extends IConnectableRuntime {
+    readonly logger: ITelemetryLoggerExt;
+    /** clientId of parent (non-summarizing) container that owns summarizer container */
+    readonly summarizerClientId: string | undefined;
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    disposeFn(): void;
+    closeFn(): void;
+    on(event: "op", listener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void): this;
+    off(event: "op", listener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void): this;
+}
+
+/**
+ * @internal
+ */
+export declare interface ISummarizingWarning extends ContainerWarning {
+    readonly errorType: "summarizingError";
+    readonly logged: boolean;
+}
+
+/**
+ * A single summary which can be tracked as it goes through its life cycle.
+ * The life cycle is: Local to Broadcast to Acked/Nacked.
+ * @internal
+ */
+export declare interface ISummary {
+    readonly clientId: string;
+    readonly clientSequenceNumber: number;
+    waitBroadcast(): Promise<ISummaryOpMessage>;
+    waitAckNack(): Promise<ISummaryAckMessage | ISummaryNackMessage>;
+}
+
+/**
+ * Interface for summary ack messages with typed contents.
+ * @alpha
+ */
+export declare interface ISummaryAckMessage extends ISequencedDocumentMessage {
+    type: MessageType.SummaryAck;
+    contents: ISummaryAck;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummaryBaseConfiguration {
+    /**
+     * Delay before first attempt to spawn summarizing container.
+     */
+    initialSummarizerDelayMs: number;
+    /**
+     * Defines the maximum allowed time to wait for a pending summary ack.
+     * The maximum amount of time client will wait for a summarize is the minimum of
+     * maxSummarizeAckWaitTime (currently 3 * 60 * 1000) and maxAckWaitTime.
+     */
+    maxAckWaitTime: number;
+    /**
+     * Defines the maximum number of Ops in between Summaries that can be
+     * allowed before forcibly electing a new summarizer client.
+     */
+    maxOpsSinceLastSummary: number;
+}
+
+/**
+ * Similar to AbortSignal, but using promise instead of events
+ * @alpha
+ */
+export declare type ISummaryCancellationToken = ICancellationToken<SummarizerStopReason>;
+
+/**
+ * @internal
+ */
+export declare interface ISummaryCollectionOpEvents extends IEvent {
+    (event: OpActionEventName, listener: OpActionEventListener): any;
+}
+
+/**
+ * @alpha
+ */
+export declare type ISummaryConfiguration = ISummaryConfigurationDisableSummarizer | ISummaryConfigurationDisableHeuristics | ISummaryConfigurationHeuristics;
+
+/**
+ * @alpha
+ */
+export declare interface ISummaryConfigurationDisableHeuristics extends ISummaryBaseConfiguration {
+    state: "disableHeuristics";
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummaryConfigurationDisableSummarizer {
+    state: "disabled";
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummaryConfigurationHeuristics extends ISummaryBaseConfiguration {
+    state: "enabled";
+    /**
+     * Defines the maximum allowed time, since the last received Ack, before running the summary
+     * with reason maxTime.
+     * For example, say we receive ops one by one just before the idle time is triggered.
+     * In this case, we still want to run a summary since it's been a while since the last summary.
+     */
+    maxTime: number;
+    /**
+     * Defines the maximum number of Ops, since the last received Ack, that can be allowed
+     * before running the summary with reason maxOps.
+     */
+    maxOps: number;
+    /**
+     * Defines the minimum number of Ops, since the last received Ack, that can be allowed
+     * before running the last summary.
+     */
+    minOpsForLastSummaryAttempt: number;
+    /**
+     * Defines the lower boundary for the allowed time in between summarizations.
+     * Pairs with maxIdleTime to form a range.
+     * For example, if we only receive 1 op, we don't want to have the same idle time as say 100 ops.
+     * Based on the boundaries we set in minIdleTime and maxIdleTime, the idle time will change
+     * linearly depending on the number of ops we receive.
+     */
+    minIdleTime: number;
+    /**
+     * Defines the upper boundary for the allowed time in between summarizations.
+     * Pairs with minIdleTime to form a range.
+     * For example, if we only receive 1 op, we don't want to have the same idle time as say 100 ops.
+     * Based on the boundaries we set in minIdleTime and maxIdleTime, the idle time will change
+     * linearly depending on the number of ops we receive.
+     */
+    maxIdleTime: number;
+    /**
+     * Runtime op weight to use in heuristic summarizing.
+     * This number is a multiplier on the number of runtime ops we process when running summarize heuristics.
+     * For example: (multiplier) * (number of runtime ops) = weighted number of runtime ops
+     */
+    runtimeOpWeight: number;
+    /**
+     * Non-runtime op weight to use in heuristic summarizing
+     * This number is a multiplier on the number of non-runtime ops we process when running summarize heuristics.
+     * For example: (multiplier) * (number of non-runtime ops) = weighted number of non-runtime ops
+     */
+    nonRuntimeOpWeight: number;
+    /**
+     * Number of ops since last summary needed before a non-runtime op can trigger running summary heuristics.
+     *
+     * Note: Any runtime ops sent before the threshold is reached will trigger heuristics normally.
+     * This threshold ONLY applies to non-runtime ops triggering summaries.
+     *
+     * For example: Say the threshold is 20. Sending 19 non-runtime ops will not trigger any heuristic checks.
+     * Sending the 20th non-runtime op will trigger the heuristic checks for summarizing.
+     */
+    nonRuntimeHeuristicThreshold?: number;
+}
+
+/**
+ * The properties of an ISequencedDocumentMessage to be stored in the metadata blob in summary.
+ * @alpha
+ */
+export declare type ISummaryMetadataMessage = Pick<ISequencedDocumentMessage, "clientId" | "clientSequenceNumber" | "minimumSequenceNumber" | "referenceSequenceNumber" | "sequenceNumber" | "timestamp" | "type">;
+
+/**
+ * Interface for summary nack messages with typed contents.
+ * @alpha
+ */
+export declare interface ISummaryNackMessage extends ISequencedDocumentMessage {
+    type: MessageType.SummaryNack;
+    contents: ISummaryNack;
+}
+
+/**
+ * Interface for summary op messages with typed contents.
+ * @alpha
+ */
+export declare interface ISummaryOpMessage extends ISequencedDocumentMessage {
+    type: MessageType.Summarize;
+    contents: ISummaryContent;
+}
+
+/**
+ * @alpha
+ */
+export declare interface ISummaryRuntimeOptions {
+    /** Override summary configurations set by the server. */
+    summaryConfigOverrides?: ISummaryConfiguration;
+    /**
+     * Delay before first attempt to spawn summarizing container.
+     *
+     * @deprecated Use {@link ISummaryRuntimeOptions.summaryConfigOverrides}'s
+     * {@link ISummaryBaseConfiguration.initialSummarizerDelayMs} instead.
+     */
+    initialSummarizerDelayMs?: number;
+}
+
+/**
+ * The statistics of the system state after a garbage collection sweep phase run.
+ * @alpha
+ */
+export declare interface ISweepPhaseStats {
+    /** The number of nodes in the lifetime of the container. */
+    lifetimeNodeCount: number;
+    /** The number of data stores in the lifetime of the container. */
+    lifetimeDataStoreCount: number;
+    /** The number of attachment blobs in the lifetime of the container. */
+    lifetimeAttachmentBlobCount: number;
+    /** The number of deleted nodes in the container. */
+    deletedNodeCount: number;
+    /** The number of deleted data stores in the container. */
+    deletedDataStoreCount: number;
+    /** The number of deleted attachment blobs in the container. */
+    deletedAttachmentBlobCount: number;
+}
+
+/**
+ * Results of submitSummary after uploading the tree to storage.
+ * @alpha
+ */
+export declare interface IUploadSummaryResult extends Omit<IGenerateSummaryTreeResult, "stage"> {
+    readonly stage: "upload";
+    /** The handle returned by storage pointing to the uploaded summary tree. */
+    readonly handle: string;
+    /** Time it took to upload the summary tree to storage. */
+    readonly uploadDuration: number;
+}
+
+/**
+ * Can be useful in testing as well as in places where caller does not use cancellation.
+ * This object implements ISummaryCancellationToken interface but cancellation is never leveraged.
+ * @internal
+ */
+export declare const neverCancelledSummaryToken: ISummaryCancellationToken;
+
+/**
+ * @internal
+ */
+export declare type OpActionEventListener = (op: ISequencedDocumentMessage) => void;
+
+/**
+ * @internal
+ */
+export declare type OpActionEventName = MessageType.Summarize | MessageType.SummaryAck | MessageType.SummaryNack | "default";
+
+/**
+ * Additional details expected for any recently added message.
+ * @internal
+ */
+export declare interface RecentlyAddedContainerRuntimeMessageDetails {
+    /** Info describing how to handle this op in case the type is unrecognized (default: fail to process) */
+    compatDetails: IContainerRuntimeMessageCompatDetails;
+}
+
+/**
+ * Accepted header keys for requests coming to the runtime.
+ * @internal
+ */
+export declare enum RuntimeHeaders {
+    /** True to wait for a data store to be created and loaded before returning it. */
+    wait = "wait",
+    /** True if the request is coming from an IFluidHandle. */
+    viaHandle = "viaHandle"
+}
+
+/**
+ * @deprecated use ContainerRuntimeMessageType instead
+ * @internal
+ */
+export declare enum RuntimeMessage {
+    FluidDataStoreOp = "component",
+    Attach = "attach",
+    ChunkedOp = "chunkedOp",
+    BlobAttach = "blobAttach",
+    Rejoin = "rejoin",
+    Alias = "alias",
+    Operation = "op"
+}
+
+/**
+ * The data in summarizer result when submit summary stage fails.
+ * @alpha
+ */
+export declare interface SubmitSummaryFailureData extends IRetriableFailureResult {
+    stage: SummaryStage;
+}
+
+/**
+ * Strict type representing result of a submitSummary attempt.
+ * The result consists of 4 possible stages, each with its own data.
+ * The data is cumulative, so each stage will contain the data from the previous stages.
+ * If the final "submitted" stage is not reached, the result may contain the error object.
+ *
+ * Stages:
+ *
+ * 1. "base" - stopped before the summary tree was even generated, and the result only contains the base data
+ *
+ * 2. "generate" - the summary tree was generated, and the result will contain that tree + stats
+ *
+ * 3. "upload" - the summary was uploaded to storage, and the result contains the server-provided handle
+ *
+ * 4. "submit" - the summarize op was submitted, and the result contains the op client sequence number.
+ * @alpha
+ */
+export declare type SubmitSummaryResult = IBaseSummarizeResult | IGenerateSummaryTreeResult | IUploadSummaryResult | ISubmitSummaryOpResult;
+
+/**
+ * Summarizer is responsible for coordinating when to generate and send summaries.
+ * It is the main entry point for summary work.
+ * It is created only by summarizing container (i.e. one with clientType === "summarizer")
+ * @internal
+ */
+export declare class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
+    /** Reference to runtime that created this object.
+     * i.e. runtime with clientType === "summarizer"
+     */
+    private readonly runtime;
+    private readonly configurationGetter;
+    /** Represents an object that can generate summary.
+     * In practical terms, it's same runtime (this.runtime) with clientType === "summarizer".
+     */
+    private readonly internalsProvider;
+    readonly summaryCollection: SummaryCollection;
+    private readonly runCoordinatorCreateFn;
+    get ISummarizer(): this;
+    private readonly logger;
+    private runningSummarizer?;
+    private _disposed;
+    private starting;
+    private readonly stopDeferred;
+    constructor(
+    /** Reference to runtime that created this object.
+     * i.e. runtime with clientType === "summarizer"
+     */
+    runtime: ISummarizerRuntime, configurationGetter: () => ISummaryConfiguration, 
+    /** Represents an object that can generate summary.
+     * In practical terms, it's same runtime (this.runtime) with clientType === "summarizer".
+     */
+    internalsProvider: ISummarizerInternalsProvider, handleContext: IFluidHandleContext, summaryCollection: SummaryCollection, runCoordinatorCreateFn: (runtime: IConnectableRuntime) => Promise<ICancellableSummarizerController>);
+    /**
+     * Creates a Summarizer and its underlying client.
+     * Note that different implementations of ILoader will handle the URL differently.
+     * ILoader provided by a ContainerRuntime is a RelativeLoader, which will treat URL's
+     * starting with "/" as relative to the Container. The general ILoader
+     * interface will expect an absolute URL and will not handle "/".
+     * @param loader - the loader that resolves the request
+     * @param url - the URL used to resolve the container
+     * @deprecated Creating a summarizer is not a publicly supported API. Please remove all usage of this static method.
+     */
+    static create(loader: ILoader, url: string): Promise<ISummarizer>;
+    run(onBehalfOf: string): Promise<SummarizerStopReason>;
+    /**
+     * Stops the summarizer from running.  This will complete
+     * the run promise, and also close the container.
+     * @param reason - reason code for stopping
+     */
+    stop(reason: SummarizerStopReason): void;
+    close(): void;
+    private runCore;
+    /**
+     * Should we try to run a last summary for the given stop reason?
+     * Currently only allows "parentNotConnected"
+     * @param stopReason - SummarizerStopReason
+     * @returns `true` if the stop reason can run a last summary, otherwise `false`.
+     */
+    static stopReasonCanRunLastSummary(stopReason: SummarizerStopReason): boolean;
+    private _heuristicData;
+    /**
+     * Put the summarizer in a started state, including creating and initializing the RunningSummarizer.
+     * The start request can come either from the SummaryManager (in the auto-summarize case) or from the user
+     * (in the on-demand case).
+     * @param onBehalfOf - ID of the client that requested that the summarizer start
+     * @param runCoordinator - cancellation token
+     * @param newConfig - Summary configuration to override the existing config when invoking the RunningSummarizer.
+     * @returns A promise that is fulfilled when the RunningSummarizer is ready.
+     */
+    private start;
+    private readonly handleSummarizeEvent;
+    /**
+     * Disposes of resources after running.  This cleanup will
+     * clear any outstanding timers and reset some of the state
+     * properties.
+     * Called by ContainerRuntime when it is disposed, as well as at the end the run().
+     */
+    dispose(): void;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    recordSummaryAttempt?(summaryRefSeqNum?: number): void;
+}
+
+/**
+ * @alpha
+ */
+export declare type SummarizeResultPart<TSuccess, TFailure = undefined> = {
+    success: true;
+    data: TSuccess;
+} | {
+    success: false;
+    data: TFailure | undefined;
+    message: string;
+    error: any;
+};
+
+/**
+ * @alpha
+ */
+export declare type SummarizerStopReason = 
+/** Summarizer client failed to summarize in all 3 consecutive attempts. */
+"failToSummarize"
+/** Parent client reported that it is no longer connected. */
+| "parentNotConnected"
+/**
+* Parent client reported that it is no longer elected the summarizer.
+* This is the normal flow; a disconnect will always trigger the parent
+* client to no longer be elected as responsible for summaries. Then it
+* tries to stop its spawned summarizer client.
+*/
+| "notElectedParent"
+/**
+* We are not already running the summarizer and we are not the current elected client id.
+*/
+| "notElectedClient"
+/** Summarizer client was disconnected */
+| "summarizerClientDisconnected"
+/** running summarizer threw an exception */
+| "summarizerException"
+/**
+* The previous summary state on the summarizer is not the most recently acked summary. this also happens when the
+* first submitSummary attempt fails for any reason and there's a 2nd summary attempt without an ack
+*/
+| "latestSummaryStateStale";
+
+/**
+ * Data structure that looks at the op stream to track summaries as they
+ * are broadcast, acked and nacked.
+ * It provides functionality for watching specific summaries.
+ * @internal
+ */
+export declare class SummaryCollection extends TypedEventEmitter<ISummaryCollectionOpEvents> {
+    private readonly deltaManager;
+    private readonly logger;
+    private readonly summaryWatchers;
+    private readonly pendingSummaries;
+    private refreshWaitNextAck;
+    private lastSummaryTimestamp;
+    private maxAckWaitTime;
+    private pendingAckTimerTimeoutCallback;
+    private lastAck;
+    get latestAck(): IAckedSummary | undefined;
+    emit(event: OpActionEventName, ...args: Parameters<OpActionEventListener>): boolean;
+    get opsSinceLastAck(): number;
+    addOpListener(listener: () => void): void;
+    removeOpListener(listener: () => void): void;
+    constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>, logger: ITelemetryLoggerExt);
+    /**
+     * Creates and returns a summary watcher for a specific client.
+     * This will allow for local sent summaries to be better tracked.
+     * @param clientId - client id for watcher
+     */
+    createWatcher(clientId: string): IClientSummaryWatcher;
+    removeWatcher(clientId: string): void;
+    setPendingAckTimerTimeoutCallback(maxAckWaitTime: number, timeoutCallback: () => void): void;
+    unsetPendingAckTimerTimeoutCallback(): void;
+    /**
+     * Returns a promise that resolves once all pending summary ops
+     * have been acked or nacked.
+     */
+    waitFlushed(): Promise<IAckedSummary | undefined>;
+    /**
+     * Returns a promise that resolves once a summary is acked that has a reference
+     * sequence number greater than or equal to the passed in sequence number.
+     * @param referenceSequenceNumber - reference sequence number to wait for
+     * @returns The latest acked summary
+     */
+    waitSummaryAck(referenceSequenceNumber: number): Promise<IAckedSummary>;
+    private parseContent;
+    /**
+     * Handler for ops; only handles ops relating to summaries.
+     * @param op - op message to handle
+     */
+    private handleOp;
+    private handleSummaryOp;
+    private handleSummaryAck;
+    private handleSummaryNack;
+}
+
+/**
+ * The stages of Summarize, used to describe how far progress succeeded in case of a failure at a later stage.
+ * @alpha
+ */
+export declare type SummaryStage = SubmitSummaryResult["stage"] | "unknown";
+
+/**
+ * This function is not supported publicly and exists for e2e testing
+ * @internal
+ */
+export declare function TEST_requestSummarizer(loader: ILoader, url: string): Promise<ISummarizer>;
+
+/**
+ * Tombstone error responses will have this header set to true
+ * @internal
+ */
+export declare const TombstoneResponseHeaderKey = "isTombstoned";
+
+/**
+ * Unpacks runtime messages.
+ *
+ * @remarks This API makes no promises regarding backward-compatibility. This is internal API.
+ * @param message - message (as it observed in storage / service)
+ * @returns whether the given message was unpacked
+ *
+ * @internal
+ */
+export declare function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean;
+
+export { }