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

package/api-report/container-runtime.api.md

@@ -0,0 +1,863 @@
+## API Report File for "@fluidframework/container-runtime"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+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 { 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 { 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';
+
+// @internal
+export const agentSchedulerId = "_scheduler";
+
+// @internal
+export const AllowInactiveRequestHeaderKey = "allowInactive";
+
+// @alpha
+export const AllowTombstoneRequestHeaderKey = "allowTombstone";
+
+export { assertIsStableId }
+
+// @internal
+export type CompatModeBehavior =
+/** Ignore the op. It won't be persisted if this client summarizes */
+"Ignore"
+/** Fail processing immediately. (The container will close) */
+| "FailToProcess";
+
+// @alpha
+export enum CompressionAlgorithms {
+    // (undocumented)
+    lz4 = "lz4"
+}
+
+// @alpha (undocumented)
+export enum ContainerMessageType {
+    // (undocumented)
+    Alias = "alias",
+    // (undocumented)
+    Attach = "attach",
+    // (undocumented)
+    BlobAttach = "blobAttach",
+    // (undocumented)
+    ChunkedOp = "chunkedOp",
+    // (undocumented)
+    FluidDataStoreOp = "component",
+    GC = "GC",
+    IdAllocation = "idAllocation",
+    // (undocumented)
+    Rejoin = "rejoin"
+}
+
+// @alpha
+export class ContainerRuntime extends TypedEventEmitter<IContainerRuntimeEvents & ISummarizerEvents> implements IContainerRuntime, IRuntime, ISummarizerRuntime, ISummarizerInternalsProvider, IProvideFluidHandleContext {
+    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);
+    // (undocumented)
+    protected addContainerStateToSummary(summaryTree: ISummaryTreeWithStats, fullTree: boolean, trackState: boolean, telemetryContext?: ITelemetryContext): void;
+    addedGCOutboundReference(srcHandle: IFluidHandle, outboundHandle: IFluidHandle): void;
+    // (undocumented)
+    get attachState(): AttachState;
+    // (undocumented)
+    readonly clientDetails: IClientDetails;
+    // (undocumented)
+    get clientId(): string | undefined;
+    // (undocumented)
+    readonly closeFn: (error?: ICriticalContainerError) => void;
+    collectGarbage(options: {
+        logger?: ITelemetryLoggerExt;
+        runSweep?: boolean;
+        fullGC?: boolean;
+    }, telemetryContext?: ITelemetryContext): Promise<IGCStats | undefined>;
+    // (undocumented)
+    get connected(): boolean;
+    // (undocumented)
+    createDataStore(pkg: string | string[]): Promise<IDataStore>;
+    // @deprecated (undocumented)
+    _createDataStoreWithProps(pkg: string | string[], props?: any, id?: string): Promise<IDataStore>;
+    // (undocumented)
+    createDetachedDataStore(pkg: Readonly<string[]>): IFluidDataStoreContextDetached;
+    // (undocumented)
+    createDetachedRootDataStore(pkg: Readonly<string[]>, rootDataStoreId: string): IFluidDataStoreContextDetached;
+    createSummary(blobRedirectTable?: Map<string, string>, telemetryContext?: ITelemetryContext): ISummaryTree;
+    deleteSweepReadyNodes(sweepReadyRoutes: readonly string[]): readonly string[];
+    // @deprecated (undocumented)
+    deleteUnusedNodes(unusedRoutes: readonly string[]): string[];
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    // (undocumented)
+    dispose(error?: Error): void;
+    // (undocumented)
+    get disposed(): boolean;
+    // (undocumented)
+    readonly disposeFn: (error?: ICriticalContainerError) => void;
+    // (undocumented)
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    ensureNoDataModelChanges<T>(callback: () => T): T;
+    // (undocumented)
+    get flushMode(): FlushMode;
+    get gcThrowOnTombstoneUsage(): boolean;
+    get gcTombstoneEnforcementAllowed(): boolean;
+    // (undocumented)
+    readonly getAbsoluteUrl: (relativeUrl: string) => Promise<string | undefined>;
+    getAliasedDataStoreEntryPoint(alias: string): Promise<IFluidHandle<FluidObject> | undefined>;
+    // (undocumented)
+    getAudience(): IAudience;
+    getCurrentReferenceTimestampMs(): number | undefined;
+    // (undocumented)
+    getEntryPoint(): Promise<FluidObject>;
+    getGCData(fullGC?: boolean): Promise<IGarbageCollectionData>;
+    getGCNodePackagePath(nodePath: string): Promise<readonly string[] | undefined>;
+    getNodeType(nodePath: string): GCNodeType;
+    // (undocumented)
+    getPendingLocalState(props?: IGetPendingLocalStateProps): Promise<unknown>;
+    // (undocumented)
+    getQuorum(): IQuorumClients;
+    // (undocumented)
+    idCompressor: (IIdCompressor & IIdCompressorCore) | undefined;
+    // (undocumented)
+    get IFluidDataStoreRegistry(): IFluidDataStoreRegistry;
+    // (undocumented)
+    get IFluidHandleContext(): IFluidHandleContext;
+    get isDirty(): boolean;
+    static loadRuntime(params: {
+        context: IContainerContext;
+        registryEntries: NamedFluidDataStoreRegistryEntries;
+        existing: boolean;
+        runtimeOptions?: IContainerRuntimeOptions;
+        containerScope?: FluidObject;
+        containerRuntimeCtor?: typeof ContainerRuntime;
+        requestHandler?: (request: IRequest, runtime: IContainerRuntime) => Promise<IResponse>;
+        provideEntryPoint: (containerRuntime: IContainerRuntime) => Promise<FluidObject>;
+    }): Promise<ContainerRuntime>;
+    // (undocumented)
+    readonly logger: ITelemetryLoggerExt;
+    // (undocumented)
+    notifyOpReplay(message: ISequencedDocumentMessage): Promise<void>;
+    // (undocumented)
+    readonly options: ILoaderOptions;
+    // (undocumented)
+    orderSequentially<T>(callback: () => T): T;
+    // (undocumented)
+    process(messageArg: ISequencedDocumentMessage, local: boolean): void;
+    // (undocumented)
+    processSignal(message: ISignalMessage, local: boolean): void;
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
+    resolveHandle(request: IRequest): Promise<IResponse>;
+    // (undocumented)
+    get scope(): FluidObject;
+    // (undocumented)
+    setAttachState(attachState: AttachState.Attaching | AttachState.Attached): void;
+    // (undocumented)
+    setConnectionState(connected: boolean, clientId?: string): void;
+    // (undocumented)
+    get storage(): IDocumentStorageService;
+    // (undocumented)
+    submitDataStoreAliasOp(contents: any, localOpMetadata: unknown): void;
+    // (undocumented)
+    submitDataStoreOp(id: string, contents: any, localOpMetadata?: unknown): void;
+    submitDataStoreSignal(address: string, type: string, content: any, targetClientId?: string): void;
+    submitSignal(type: string, content: any, targetClientId?: string): void;
+    submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
+    summarize(options: {
+        fullTree?: boolean;
+        trackState?: boolean;
+        summaryLogger?: ITelemetryLoggerExt;
+        runGC?: boolean;
+        fullGC?: boolean;
+        runSweep?: boolean;
+    }): Promise<ISummaryTreeWithStats>;
+    // (undocumented)
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    get summarizerClientId(): string | undefined;
+    updateStateBeforeGC(): Promise<void>;
+    updateTombstonedRoutes(tombstonedRoutes: readonly string[]): void;
+    updateUnusedRoutes(unusedRoutes: readonly string[]): void;
+    updateUsedRoutes(usedRoutes: readonly string[]): void;
+    // (undocumented)
+    uploadBlob(blob: ArrayBufferLike, signal?: AbortSignal): Promise<IFluidHandle<ArrayBufferLike>>;
+}
+
+// @internal @deprecated
+export interface ContainerRuntimeMessage {
+    compatDetails?: IContainerRuntimeMessageCompatDetails;
+    contents: any;
+    type: ContainerMessageType;
+}
+
+// @alpha (undocumented)
+export const DefaultSummaryConfiguration: ISummaryConfiguration;
+
+// @alpha (undocumented)
+export type EnqueueSummarizeResult = (ISummarizeResults & {
+    readonly alreadyEnqueued?: undefined;
+}) | (ISummarizeResults & {
+    readonly alreadyEnqueued: true;
+    readonly overridden: true;
+}) | {
+    readonly alreadyEnqueued: true;
+    readonly overridden?: undefined;
+};
+
+// @internal (undocumented)
+export class FluidDataStoreRegistry implements IFluidDataStoreRegistry {
+    constructor(namedEntries: NamedFluidDataStoreRegistryEntries);
+    // (undocumented)
+    get(name: string): Promise<FluidDataStoreRegistryEntry | undefined>;
+    // (undocumented)
+    get IFluidDataStoreRegistry(): this;
+}
+
+// @alpha (undocumented)
+export type GCFeatureMatrix = {
+    gcGeneration?: number;
+    tombstoneGeneration?: undefined;
+} | {
+    tombstoneGeneration: number;
+};
+
+// @alpha
+export const GCNodeType: {
+    DataStore: string;
+    SubDataStore: string;
+    Blob: string;
+    Other: string;
+};
+
+// @alpha (undocumented)
+export type GCNodeType = (typeof GCNodeType)[keyof typeof GCNodeType];
+
+// @alpha (undocumented)
+export type GCVersion = number;
+
+export { generateStableId }
+
+// @alpha
+export interface IAckedSummary {
+    // (undocumented)
+    readonly summaryAck: ISummaryAckMessage;
+    // (undocumented)
+    readonly summaryOp: ISummaryOpMessage;
+}
+
+// @alpha (undocumented)
+export interface IAckSummaryResult {
+    // (undocumented)
+    readonly ackNackDuration: number;
+    // (undocumented)
+    readonly summaryAckOp: ISummaryAckMessage;
+}
+
+// @alpha
+export interface IBaseSummarizeResult {
+    readonly error: any;
+    // (undocumented)
+    readonly minimumSequenceNumber: number;
+    readonly referenceSequenceNumber: number;
+    // (undocumented)
+    readonly stage: "base";
+}
+
+// @alpha
+export interface IBlobManagerLoadInfo {
+    // (undocumented)
+    ids?: string[];
+    // (undocumented)
+    redirectTable?: [string, string][];
+}
+
+// @alpha (undocumented)
+export interface IBroadcastSummaryResult {
+    // (undocumented)
+    readonly broadcastDuration: number;
+    // (undocumented)
+    readonly summarizeOp: ISummaryOpMessage;
+}
+
+// @alpha
+export interface ICancellableSummarizerController extends ISummaryCancellationToken {
+    // (undocumented)
+    stop(reason: SummarizerStopReason): void;
+}
+
+// @alpha
+export interface ICancellationToken<T> {
+    readonly cancelled: boolean;
+    readonly waitCancelled: Promise<T>;
+}
+
+// @internal (undocumented)
+export interface IChunkedOp {
+    // (undocumented)
+    chunkId: number;
+    // (undocumented)
+    contents: string;
+    // (undocumented)
+    originalCompression?: string;
+    // (undocumented)
+    originalMetadata?: Record<string, unknown>;
+    // (undocumented)
+    originalType: MessageType | ContainerMessageType;
+    // (undocumented)
+    totalChunks: number;
+}
+
+// @alpha
+export interface IClientSummaryWatcher extends IDisposable {
+    // (undocumented)
+    waitFlushed(): Promise<IAckedSummary | undefined>;
+    // (undocumented)
+    watchSummary(clientSequenceNumber: number): ISummary;
+}
+
+// @alpha
+export interface ICompressionRuntimeOptions {
+    readonly compressionAlgorithm: CompressionAlgorithms;
+    readonly minimumBatchSizeInBytes: number;
+}
+
+// @alpha (undocumented)
+export interface IConnectableRuntime {
+    // (undocumented)
+    readonly clientId: string | undefined;
+    // (undocumented)
+    readonly connected: boolean;
+    // (undocumented)
+    readonly disposed: boolean;
+    // (undocumented)
+    once(event: "connected" | "disconnected" | "dispose", listener: () => void): this;
+}
+
+// @internal
+export interface IContainerRuntimeMessageCompatDetails {
+    behavior: CompatModeBehavior;
+}
+
+// @alpha (undocumented)
+export interface IContainerRuntimeMetadata extends ICreateContainerMetadata, IGCMetadata {
+    readonly disableIsolatedChannels?: true;
+    readonly idCompressorEnabled?: boolean;
+    readonly message: ISummaryMetadataMessage | undefined;
+    // (undocumented)
+    readonly summaryFormatVersion: 1;
+    readonly summaryNumber?: number;
+    readonly telemetryDocumentId?: string;
+}
+
+// @alpha
+export interface IContainerRuntimeOptions {
+    readonly chunkSizeInBytes?: number;
+    readonly compressionOptions?: ICompressionRuntimeOptions;
+    readonly enableGroupedBatching?: boolean;
+    readonly enableOpReentryCheck?: boolean;
+    readonly enableRuntimeIdCompressor?: boolean;
+    readonly flushMode?: FlushMode;
+    // (undocumented)
+    readonly gcOptions?: IGCRuntimeOptions;
+    readonly loadSequenceNumberVerification?: "close" | "log" | "bypass";
+    readonly maxBatchSizeInBytes?: number;
+    // (undocumented)
+    readonly summaryOptions?: ISummaryRuntimeOptions;
+}
+
+// @alpha (undocumented)
+export interface ICreateContainerMetadata {
+    createContainerRuntimeVersion?: string;
+    createContainerTimestamp?: number;
+}
+
+// @alpha
+export interface IEnqueueSummarizeOptions extends IOnDemandSummarizeOptions {
+    readonly afterSequenceNumber?: number;
+    readonly override?: boolean;
+}
+
+// @alpha
+export interface IGCMetadata {
+    readonly gcFeature?: GCVersion;
+    readonly gcFeatureMatrix?: GCFeatureMatrix;
+    readonly sessionExpiryTimeoutMs?: number;
+    // @deprecated
+    readonly sweepEnabled?: boolean;
+    readonly tombstoneTimeoutMs?: number;
+}
+
+// @alpha (undocumented)
+export interface IGCRuntimeOptions {
+    [key: string]: any;
+    disableGC?: boolean;
+    enableGCSweep?: true;
+    gcAllowed?: boolean;
+    runFullGC?: boolean;
+    sessionExpiryTimeoutMs?: number;
+    sweepGracePeriodMs?: number;
+}
+
+// @alpha
+export interface IGCStats extends IMarkPhaseStats, ISweepPhaseStats {
+}
+
+// @alpha
+export interface IGeneratedSummaryStats extends ISummaryStats {
+    readonly dataStoreCount: number;
+    readonly gcBlobNodeCount?: number;
+    readonly gcStateUpdatedDataStoreCount?: number;
+    readonly gcTotalBlobsSize?: number;
+    readonly summarizedDataStoreCount: number;
+    readonly summaryNumber: number;
+}
+
+// @alpha
+export interface IGenerateSummaryTreeResult extends Omit<IBaseSummarizeResult, "stage"> {
+    readonly forcedFullTree: boolean;
+    readonly generateDuration: number;
+    // (undocumented)
+    readonly stage: "generate";
+    readonly summaryStats: IGeneratedSummaryStats;
+    readonly summaryTree: ISummaryTree;
+}
+
+// @alpha
+export interface IMarkPhaseStats {
+    attachmentBlobCount: number;
+    dataStoreCount: number;
+    nodeCount: number;
+    unrefAttachmentBlobCount: number;
+    unrefDataStoreCount: number;
+    unrefNodeCount: number;
+    updatedAttachmentBlobCount: number;
+    updatedDataStoreCount: number;
+    updatedNodeCount: number;
+}
+
+// @alpha (undocumented)
+export interface INackSummaryResult extends IRetriableFailureResult {
+    // (undocumented)
+    readonly ackNackDuration: number;
+    // (undocumented)
+    readonly summaryNackOp: ISummaryNackMessage;
+}
+
+// @alpha
+export const InactiveResponseHeaderKey = "isInactive";
+
+// @alpha (undocumented)
+export interface IOnDemandSummarizeOptions extends ISummarizeOptions {
+    readonly reason: string;
+}
+
+// @alpha
+export interface IRefreshSummaryAckOptions {
+    readonly ackHandle: string;
+    readonly proposalHandle: string | undefined;
+    readonly summaryLogger: ITelemetryLoggerExt;
+    readonly summaryRefSeq: number;
+}
+
+// @alpha
+export interface IRetriableFailureResult {
+    // (undocumented)
+    readonly retryAfterSeconds?: number;
+}
+
+// @alpha
+export interface ISerializedElection {
+    readonly electedClientId: string | undefined;
+    readonly electedParentId: string | undefined;
+    readonly electionSequenceNumber: number;
+}
+
+// @internal @deprecated (undocumented)
+export function isRuntimeMessage(message: ISequencedDocumentMessage): boolean;
+
+export { isStableId }
+
+// @alpha
+export interface ISubmitSummaryOpResult extends Omit<IUploadSummaryResult, "stage" | "error"> {
+    readonly clientSequenceNumber: number;
+    // (undocumented)
+    readonly stage: "submit";
+    readonly submitOpDuration: number;
+}
+
+// @alpha (undocumented)
+export interface ISubmitSummaryOptions extends ISummarizeOptions {
+    readonly cancellationToken: ISummaryCancellationToken;
+    readonly finalAttempt?: boolean;
+    readonly summaryLogger: ITelemetryLoggerExt;
+}
+
+// @alpha (undocumented)
+export interface ISummarizeEventProps {
+    // (undocumented)
+    currentAttempt: number;
+    // (undocumented)
+    error?: any;
+    // (undocumented)
+    maxAttempts: number;
+    // (undocumented)
+    result: "success" | "failure" | "canceled";
+}
+
+// @alpha
+export interface ISummarizeOptions {
+    readonly fullTree?: boolean;
+    // @deprecated
+    readonly refreshLatestAck?: boolean;
+}
+
+// @alpha (undocumented)
+export interface ISummarizer extends IEventProvider<ISummarizerEvents> {
+    // (undocumented)
+    close(): void;
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    readonly ISummarizer?: ISummarizer;
+    // (undocumented)
+    run(onBehalfOf: string, disableHeuristics?: boolean): Promise<SummarizerStopReason>;
+    // (undocumented)
+    stop(reason: SummarizerStopReason): void;
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+}
+
+// @alpha (undocumented)
+export interface ISummarizeResults {
+    readonly receivedSummaryAckOrNack: Promise<SummarizeResultPart<IAckSummaryResult, INackSummaryResult>>;
+    readonly summaryOpBroadcasted: Promise<SummarizeResultPart<IBroadcastSummaryResult>>;
+    readonly summarySubmitted: Promise<SummarizeResultPart<SubmitSummaryResult, SubmitSummaryFailureData>>;
+}
+
+// @alpha (undocumented)
+export interface ISummarizerEvents extends IEvent {
+    // (undocumented)
+    (event: "summarize", listener: (props: ISummarizeEventProps) => void): any;
+}
+
+// @alpha (undocumented)
+export interface ISummarizerInternalsProvider {
+    refreshLatestSummaryAck(options: IRefreshSummaryAckOptions): Promise<void>;
+    submitSummary(options: ISubmitSummaryOptions): Promise<SubmitSummaryResult>;
+}
+
+// @alpha (undocumented)
+export interface ISummarizerRuntime extends IConnectableRuntime {
+    // (undocumented)
+    closeFn(): void;
+    // (undocumented)
+    readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>;
+    // (undocumented)
+    disposeFn(): void;
+    // (undocumented)
+    readonly logger: ITelemetryLoggerExt;
+    // (undocumented)
+    off(event: "op", listener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void): this;
+    // (undocumented)
+    on(event: "op", listener: (op: ISequencedDocumentMessage, runtimeMessage?: boolean) => void): this;
+    readonly summarizerClientId: string | undefined;
+}
+
+// @internal (undocumented)
+export interface ISummarizingWarning extends ContainerWarning {
+    // (undocumented)
+    readonly errorType: "summarizingError";
+    // (undocumented)
+    readonly logged: boolean;
+}
+
+// @alpha
+export interface ISummary {
+    // (undocumented)
+    readonly clientId: string;
+    // (undocumented)
+    readonly clientSequenceNumber: number;
+    // (undocumented)
+    waitAckNack(): Promise<ISummaryAckMessage | ISummaryNackMessage>;
+    // (undocumented)
+    waitBroadcast(): Promise<ISummaryOpMessage>;
+}
+
+// @alpha
+export interface ISummaryAckMessage extends ISequencedDocumentMessage {
+    // (undocumented)
+    contents: ISummaryAck;
+    // (undocumented)
+    type: MessageType.SummaryAck;
+}
+
+// @alpha (undocumented)
+export interface ISummaryBaseConfiguration {
+    initialSummarizerDelayMs: number;
+    maxAckWaitTime: number;
+    maxOpsSinceLastSummary: number;
+}
+
+// @alpha
+export type ISummaryCancellationToken = ICancellationToken<SummarizerStopReason>;
+
+// @alpha (undocumented)
+export interface ISummaryCollectionOpEvents extends IEvent {
+    // (undocumented)
+    (event: OpActionEventName, listener: OpActionEventListener): any;
+}
+
+// @alpha (undocumented)
+export type ISummaryConfiguration = ISummaryConfigurationDisableSummarizer | ISummaryConfigurationDisableHeuristics | ISummaryConfigurationHeuristics;
+
+// @alpha (undocumented)
+export interface ISummaryConfigurationDisableHeuristics extends ISummaryBaseConfiguration {
+    // (undocumented)
+    state: "disableHeuristics";
+}
+
+// @alpha (undocumented)
+export interface ISummaryConfigurationDisableSummarizer {
+    // (undocumented)
+    state: "disabled";
+}
+
+// @alpha (undocumented)
+export interface ISummaryConfigurationHeuristics extends ISummaryBaseConfiguration {
+    maxIdleTime: number;
+    maxOps: number;
+    maxTime: number;
+    minIdleTime: number;
+    minOpsForLastSummaryAttempt: number;
+    nonRuntimeHeuristicThreshold?: number;
+    nonRuntimeOpWeight: number;
+    runtimeOpWeight: number;
+    // (undocumented)
+    state: "enabled";
+}
+
+// @alpha
+export type ISummaryMetadataMessage = Pick<ISequencedDocumentMessage, "clientId" | "clientSequenceNumber" | "minimumSequenceNumber" | "referenceSequenceNumber" | "sequenceNumber" | "timestamp" | "type">;
+
+// @alpha
+export interface ISummaryNackMessage extends ISequencedDocumentMessage {
+    // (undocumented)
+    contents: ISummaryNack;
+    // (undocumented)
+    type: MessageType.SummaryNack;
+}
+
+// @alpha
+export interface ISummaryOpMessage extends ISequencedDocumentMessage {
+    // (undocumented)
+    contents: ISummaryContent;
+    // (undocumented)
+    type: MessageType.Summarize;
+}
+
+// @alpha (undocumented)
+export interface ISummaryRuntimeOptions {
+    // @deprecated
+    initialSummarizerDelayMs?: number;
+    summaryConfigOverrides?: ISummaryConfiguration;
+}
+
+// @alpha
+export interface ISweepPhaseStats {
+    deletedAttachmentBlobCount: number;
+    deletedDataStoreCount: number;
+    deletedNodeCount: number;
+    lifetimeAttachmentBlobCount: number;
+    lifetimeDataStoreCount: number;
+    lifetimeNodeCount: number;
+}
+
+// @alpha
+export interface IUploadSummaryResult extends Omit<IGenerateSummaryTreeResult, "stage"> {
+    readonly handle: string;
+    // (undocumented)
+    readonly stage: "upload";
+    readonly uploadDuration: number;
+}
+
+// @internal
+export const neverCancelledSummaryToken: ISummaryCancellationToken;
+
+// @alpha (undocumented)
+export type OpActionEventListener = (op: ISequencedDocumentMessage) => void;
+
+// @alpha (undocumented)
+export type OpActionEventName = MessageType.Summarize | MessageType.SummaryAck | MessageType.SummaryNack | "default";
+
+// @internal
+export interface RecentlyAddedContainerRuntimeMessageDetails {
+    compatDetails: IContainerRuntimeMessageCompatDetails;
+}
+
+// @internal
+export enum RuntimeHeaders {
+    viaHandle = "viaHandle",
+    wait = "wait"
+}
+
+// @internal @deprecated (undocumented)
+export enum RuntimeMessage {
+    // (undocumented)
+    Alias = "alias",
+    // (undocumented)
+    Attach = "attach",
+    // (undocumented)
+    BlobAttach = "blobAttach",
+    // (undocumented)
+    ChunkedOp = "chunkedOp",
+    // (undocumented)
+    FluidDataStoreOp = "component",
+    // (undocumented)
+    Operation = "op",
+    // (undocumented)
+    Rejoin = "rejoin"
+}
+
+// @alpha
+export interface SubmitSummaryFailureData extends IRetriableFailureResult {
+    // (undocumented)
+    stage: SummaryStage;
+}
+
+// @alpha
+export type SubmitSummaryResult = IBaseSummarizeResult | IGenerateSummaryTreeResult | IUploadSummaryResult | ISubmitSummaryOpResult;
+
+// @alpha
+export class Summarizer extends TypedEventEmitter<ISummarizerEvents> implements ISummarizer {
+    constructor(
+    runtime: ISummarizerRuntime, configurationGetter: () => ISummaryConfiguration,
+    internalsProvider: ISummarizerInternalsProvider, handleContext: IFluidHandleContext, summaryCollection: SummaryCollection, runCoordinatorCreateFn: (runtime: IConnectableRuntime) => Promise<ICancellableSummarizerController>);
+    // (undocumented)
+    close(): void;
+    dispose(): void;
+    // (undocumented)
+    enqueueSummarize(options: IEnqueueSummarizeOptions): EnqueueSummarizeResult;
+    // (undocumented)
+    get ISummarizer(): this;
+    // (undocumented)
+    recordSummaryAttempt?(summaryRefSeqNum?: number): void;
+    // (undocumented)
+    run(onBehalfOf: string): Promise<SummarizerStopReason>;
+    stop(reason: SummarizerStopReason): void;
+    static stopReasonCanRunLastSummary(stopReason: SummarizerStopReason): boolean;
+    // (undocumented)
+    summarizeOnDemand(options: IOnDemandSummarizeOptions): ISummarizeResults;
+    // (undocumented)
+    readonly summaryCollection: SummaryCollection;
+}
+
+// @alpha (undocumented)
+export type SummarizeResultPart<TSuccess, TFailure = undefined> = {
+    success: true;
+    data: TSuccess;
+} | {
+    success: false;
+    data: TFailure | undefined;
+    message: string;
+    error: any;
+};
+
+// @alpha (undocumented)
+export 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";
+
+// @alpha
+export class SummaryCollection extends TypedEventEmitter<ISummaryCollectionOpEvents> {
+    constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>, logger: ITelemetryLoggerExt);
+    // (undocumented)
+    addOpListener(listener: () => void): void;
+    createWatcher(clientId: string): IClientSummaryWatcher;
+    // (undocumented)
+    emit(event: OpActionEventName, ...args: Parameters<OpActionEventListener>): boolean;
+    // (undocumented)
+    get latestAck(): IAckedSummary | undefined;
+    // (undocumented)
+    get opsSinceLastAck(): number;
+    // (undocumented)
+    removeOpListener(listener: () => void): void;
+    // (undocumented)
+    removeWatcher(clientId: string): void;
+    // (undocumented)
+    setPendingAckTimerTimeoutCallback(maxAckWaitTime: number, timeoutCallback: () => void): void;
+    // (undocumented)
+    unsetPendingAckTimerTimeoutCallback(): void;
+    waitFlushed(): Promise<IAckedSummary | undefined>;
+    waitSummaryAck(referenceSequenceNumber: number): Promise<IAckedSummary>;
+}
+
+// @alpha
+export type SummaryStage = SubmitSummaryResult["stage"] | "unknown";
+
+// @alpha
+export const TombstoneResponseHeaderKey = "isTombstoned";
+
+// @internal
+export function unpackRuntimeMessage(message: ISequencedDocumentMessage): boolean;
+
+// (No @packageDocumentation comment for this package)
+
+```