@fluidframework/driver-utils 1.4.0-115997 → 2.0.0-dev-rc.1.0.0.224419

package/.eslintrc.js

@@ -4,10 +4,20 @@
  */
 
 module.exports = {
-    "extends": [
-        require.resolve("@fluidframework/eslint-config-fluid")
-    ],
-    "parserOptions": {
-        "project": ["./tsconfig.json", "./src/test/tsconfig.json"]
-    },
-}
+	extends: [require.resolve("@fluidframework/eslint-config-fluid/minimal"), "prettier"],
+	parserOptions: {
+		project: ["./tsconfig.json", "./src/test/tsconfig.json"],
+	},
+	rules: {
+		"import/no-nodejs-modules": ["error", { allow: ["url"] }],
+	},
+	overrides: [
+		{
+			// Rules only for test files
+			files: ["*.spec.ts", "src/test/**"],
+			rules: {
+				"import/no-nodejs-modules": "off", // Node libraries are OK for test files.
+			},
+		},
+	],
+};

package/.mocharc.js

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+"use strict";
+
+const getFluidTestMochaConfig = require("@fluidframework/mocha-test-setup/mocharc-common");
+
+const packageDir = __dirname;
+const config = getFluidTestMochaConfig(packageDir);
+module.exports = config;

package/CHANGELOG.md

@@ -0,0 +1,141 @@
+# @fluidframework/driver-utils
+
+## 2.0.0-internal.8.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.7.0.0
+
+### Major Changes
+
+-   odsp-driver: Load container in readonly mode when driver throws DriverErrorType.outOfStorage [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Handle DriverErrorType.outOfStorage error from driver and load the container in readonly mode. Currently there is no
+    handling and when the join session throws this error, the container will get closed. With this we use NoDeltaStream
+    object as connection and load the container in read mode, so that it loads properly. We also notify the that the
+    container is "readonly" through the event on delta manager so that apps can listen to this and show any UX etc. The app
+    can listen to the event like this:
+
+    ```ts
+    container.deltaManager.on(
+    	"readonly",
+    	(readonly?: boolean, readonlyConnectionReason?: { text: string; error?: IErrorBase }) => {
+    		// error?.errorType will be equal to DriverErrorType.outOfStorage in this case
+    		// App logic
+    	},
+    );
+    ```
+
+-   Dependencies on @fluidframework/protocol-definitions package updated to 3.0.0 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    This included the following changes from the protocol-definitions release:
+
+    -   Updating signal interfaces for some planned improvements. The intention is split the interface between signals
+        submitted by clients to the server and the resulting signals sent from the server to clients.
+        -   A new optional type member is available on the ISignalMessage interface and a new ISentSignalMessage interface has
+            been added, which will be the typing for signals sent from the client to the server. Both extend a new
+            ISignalMessageBase interface that contains common members.
+    -   The @fluidframework/common-definitions package dependency has been updated to version 1.0.0.
+
+-   Server upgrade: dependencies on Fluid server packages updated to 2.0.1 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    Dependencies on the following Fluid server package have been updated to version 2.0.1:
+
+    -   @fluidframework/gitresources: 2.0.1
+    -   @fluidframework/server-kafka-orderer: 2.0.1
+    -   @fluidframework/server-lambdas: 2.0.1
+    -   @fluidframework/server-lambdas-driver: 2.0.1
+    -   @fluidframework/server-local-server: 2.0.1
+    -   @fluidframework/server-memory-orderer: 2.0.1
+    -   @fluidframework/protocol-base: 2.0.1
+    -   @fluidframework/server-routerlicious: 2.0.1
+    -   @fluidframework/server-routerlicious-base: 2.0.1
+    -   @fluidframework/server-services: 2.0.1
+    -   @fluidframework/server-services-client: 2.0.1
+    -   @fluidframework/server-services-core: 2.0.1
+    -   @fluidframework/server-services-ordering-kafkanode: 2.0.1
+    -   @fluidframework/server-services-ordering-rdkafka: 2.0.1
+    -   @fluidframework/server-services-ordering-zookeeper: 2.0.1
+    -   @fluidframework/server-services-shared: 2.0.1
+    -   @fluidframework/server-services-telemetry: 2.0.1
+    -   @fluidframework/server-services-utils: 2.0.1
+    -   @fluidframework/server-test-utils: 2.0.1
+    -   tinylicious: 2.0.1
+
+-   Minimum TypeScript version now 5.1.6 [871b3493dd](https://github.com/microsoft/FluidFramework/commits/871b3493dd0d7ea3a89be64998ceb6cb9021a04e)
+
+    The minimum supported TypeScript version for Fluid 2.0 clients is now 5.1.6.
+
+## 2.0.0-internal.6.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.6.0.0
+
+### Major Changes
+
+-   combineAppAndProtocolSummary removed from driver-utils [8abce8cdb4](https://github.com/microsoft/FluidFramework/commits/8abce8cdb4e2832fb6405fb44e393bef03d5648a)
+
+    combineAppAndProtocolSummary was deprecated in 2.0.0-internal.3.4.0 and has now been removed.
+
+-   Upgraded typescript transpilation target to ES2020 [8abce8cdb4](https://github.com/microsoft/FluidFramework/commits/8abce8cdb4e2832fb6405fb44e393bef03d5648a)
+
+    Upgraded typescript transpilation target to ES2020. This is done in order to decrease the bundle sizes of Fluid Framework packages. This has provided size improvements across the board for ex. Loader, Driver, Runtime etc. Reduced bundle sizes helps to load lesser code in apps and hence also helps to improve the perf.If any app wants to target any older versions of browsers with which this target version is not compatible, then they can use packages like babel to transpile to a older target.
+
+## 2.0.0-internal.5.4.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.3.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.2.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.1.0
+
+Dependency updates only.
+
+## 2.0.0-internal.5.0.0
+
+Dependency updates only.
+
+## 2.0.0-internal.4.4.0
+
+### Minor Changes
+
+-   The following classes have been moved from `@fluidframework/protocol-base` to `@fluidframework/driver-utils`: `BlobTreeEntry`, `TreeTreeEntry` and `AttachmentTreeEntry`. ([#15687](https://github.com/microsoft/FluidFramework/pull/15687)) [c0d2f364e8](https://github.com/microsoft/FluidFramework/commits/c0d2f364e830a7b62ec42999df8c45941f7f0a2c)
+
+## 2.0.0-internal.4.1.0
+
+Dependency updates only.

package/README.md

@@ -2,4 +2,71 @@
 
 Utilities for driver implementations.
 
-See [GitHub](https://github.com/microsoft/FluidFramework) for more details on the Fluid Framework and packages within.
+<!-- AUTO-GENERATED-CONTENT:START (LIBRARY_PACKAGE_README:scripts=FALSE) -->
+
+<!-- prettier-ignore-start -->
+<!-- NOTE: This section is automatically generated using @fluid-tools/markdown-magic. Do not update these generated contents directly. -->
+
+## Using Fluid Framework libraries
+
+When taking a dependency on a Fluid Framework library, we recommend using a `^` (caret) version range, such as `^1.3.4`.
+While Fluid Framework libraries may use different ranges with interdependencies between other Fluid Framework libraries,
+library consumers should always prefer `^`.
+
+Note that when depending on a library version of the form `2.0.0-internal.x.y.z`, called the Fluid internal version scheme,
+you must use a `>= <` dependency range (such as `>=2.0.0-internal.x.y.z <2.0.0-internal.w.0.0` where `w` is `x+1`).
+Standard `^` and `~` ranges will not work as expected.
+See the [@fluid-tools/version-tools](https://github.com/microsoft/FluidFramework/blob/main/build-tools/packages/version-tools/README.md)
+package for more information including tools to convert between version schemes.
+
+## Installation
+
+To get started, install the package by running the following command:
+
+```bash
+npm i @fluidframework/driver-utils
+```
+
+## API Documentation
+
+API documentation for **@fluidframework/driver-utils** is available at <https://fluidframework.com/docs/apis/driver-utils>.
+
+## Contribution Guidelines
+
+There are many ways to [contribute](https://github.com/microsoft/FluidFramework/blob/main/CONTRIBUTING.md) to Fluid.
+
+-   Participate in Q&A in our [GitHub Discussions](https://github.com/microsoft/FluidFramework/discussions).
+-   [Submit bugs](https://github.com/microsoft/FluidFramework/issues) and help us verify fixes as they are checked in.
+-   Review the [source code changes](https://github.com/microsoft/FluidFramework/pulls).
+-   [Contribute bug fixes](https://github.com/microsoft/FluidFramework/blob/main/CONTRIBUTING.md).
+
+Detailed instructions for working in the repo can be found in the [Wiki](https://github.com/microsoft/FluidFramework/wiki).
+
+This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/).
+For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+Use of these trademarks or logos must follow Microsoft’s [Trademark & Brand Guidelines](https://www.microsoft.com/trademarks).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+
+## Help
+
+Not finding what you're looking for in this README? Check out our [GitHub
+Wiki](https://github.com/microsoft/FluidFramework/wiki) or [fluidframework.com](https://fluidframework.com/docs/).
+
+Still not finding what you're looking for? Please [file an
+issue](https://github.com/microsoft/FluidFramework/wiki/Submitting-Bugs-and-Feature-Requests).
+
+Thank you!
+
+## Trademark
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+
+Use of these trademarks or logos must follow Microsoft's [Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+
+<!-- prettier-ignore-end -->
+
+<!-- AUTO-GENERATED-CONTENT:END -->

package/api-extractor-lint.json

@@ -0,0 +1,4 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-lint.json"
+}

package/api-extractor.json

@@ -1,4 +1,4 @@
 {
-  "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-  "extends": "@fluidframework/build-common/api-extractor-common-report.json"
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-base.json"
 }

package/api-report/driver-utils.api.md

@@ -0,0 +1,401 @@
+## API Report File for "@fluidframework/driver-utils"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { FetchSource } from '@fluidframework/driver-definitions';
+import { IAttachment } from '@fluidframework/protocol-definitions';
+import { IAuthorizationError } from '@fluidframework/driver-definitions';
+import { IBlob } from '@fluidframework/protocol-definitions';
+import { ICommittedProposal } from '@fluidframework/protocol-definitions';
+import { ICreateBlobResponse } from '@fluidframework/protocol-definitions';
+import { IDeltasFetchResult } from '@fluidframework/driver-definitions';
+import { IDocumentAttributes } from '@fluidframework/protocol-definitions';
+import { IDocumentMessage } from '@fluidframework/protocol-definitions';
+import { IDocumentServiceFactory } from '@fluidframework/driver-definitions';
+import { IDocumentStorageService } from '@fluidframework/driver-definitions';
+import { IDocumentStorageServicePolicies } from '@fluidframework/driver-definitions';
+import { IDriverErrorBase } from '@fluidframework/driver-definitions';
+import { IFluidErrorBase } from '@fluidframework/telemetry-utils';
+import { ILocationRedirectionError } from '@fluidframework/driver-definitions';
+import { IRequest } from '@fluidframework/core-interfaces';
+import { IResolvedUrl } from '@fluidframework/driver-definitions';
+import { ISequencedDocumentMessage } from '@fluidframework/protocol-definitions';
+import { ISnapshotTree } from '@fluidframework/protocol-definitions';
+import { IStream } from '@fluidframework/driver-definitions';
+import { IStreamResult } from '@fluidframework/driver-definitions';
+import { ISummaryContext } from '@fluidframework/driver-definitions';
+import { ISummaryHandle } from '@fluidframework/protocol-definitions';
+import { ISummaryTree } from '@fluidframework/protocol-definitions';
+import { ITelemetryErrorEvent } from '@fluidframework/core-interfaces';
+import { ITelemetryLoggerExt } from '@fluidframework/telemetry-utils';
+import { ITelemetryProperties } from '@fluidframework/core-interfaces';
+import { IThrottlingWarning } from '@fluidframework/driver-definitions';
+import { ITree } from '@fluidframework/protocol-definitions';
+import { ITreeEntry } from '@fluidframework/protocol-definitions';
+import { IUrlResolver } from '@fluidframework/driver-definitions';
+import { IVersion } from '@fluidframework/protocol-definitions';
+import { LoaderCachingPolicy } from '@fluidframework/driver-definitions';
+import { LoggingError } from '@fluidframework/telemetry-utils';
+
+// @internal
+export function applyStorageCompression(documentServiceFactory: IDocumentServiceFactory, config?: ICompressionStorageConfig | boolean): IDocumentServiceFactory;
+
+// @internal
+export class AttachmentTreeEntry {
+    constructor(path: string, id: string);
+    // (undocumented)
+    readonly id: string;
+    // (undocumented)
+    readonly mode = FileMode.File;
+    // (undocumented)
+    readonly path: string;
+    // (undocumented)
+    readonly type = TreeEntry.Attachment;
+    // (undocumented)
+    readonly value: IAttachment;
+}
+
+// @internal (undocumented)
+export class AuthorizationError extends LoggingError implements IAuthorizationError, IFluidErrorBase {
+    constructor(message: string, claims: string | undefined, tenantId: string | undefined, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry = false;
+    // (undocumented)
+    readonly claims: string | undefined;
+    // (undocumented)
+    readonly errorType = DriverErrorType.authorizationError;
+    // (undocumented)
+    readonly tenantId: string | undefined;
+}
+
+// @internal (undocumented)
+export const blobHeadersBlobName = ".metadata.blobHeaders";
+
+// @internal
+export class BlobTreeEntry {
+    constructor(path: string, contents: string, encoding?: "utf-8" | "base64");
+    // (undocumented)
+    readonly mode = FileMode.File;
+    // (undocumented)
+    readonly path: string;
+    // (undocumented)
+    readonly type = TreeEntry.Blob;
+    // (undocumented)
+    readonly value: IBlob;
+}
+
+// @internal
+export function buildSnapshotTree(entries: ITreeEntry[], blobMap: Map<string, ArrayBufferLike>): ISnapshotTree;
+
+// @internal
+export function calculateMaxWaitTime(delayMs: number, error: unknown): number;
+
+// @internal (undocumented)
+export function canBeCoalescedByService(message: ISequencedDocumentMessage | IDocumentMessage): boolean;
+
+// @internal
+export const canRetryOnError: (error: any) => boolean;
+
+// @internal
+export interface CombinedAppAndProtocolSummary extends ISummaryTree {
+    // (undocumented)
+    tree: {
+        [".app"]: ISummaryTree;
+        [".protocol"]: ISummaryTree;
+    };
+}
+
+// @internal
+export function convertSummaryTreeToSnapshotITree(summaryTree: ISummaryTree): ITree;
+
+// @internal (undocumented)
+export function createGenericNetworkError(message: string, retryInfo: {
+    canRetry: boolean;
+    retryAfterMs?: number;
+}, props: DriverErrorTelemetryProps): ThrottlingError | GenericNetworkError;
+
+// @internal (undocumented)
+export const createWriteError: (message: string, props: DriverErrorTelemetryProps) => NonRetryableError<"writeError">;
+
+// @internal (undocumented)
+export class DeltaStreamConnectionForbiddenError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
+    constructor(message: string, props: DriverErrorTelemetryProps, storageOnlyReason?: string);
+    // (undocumented)
+    readonly canRetry = false;
+    // (undocumented)
+    static readonly errorType = DriverErrorType.deltaStreamConnectionForbidden;
+    // (undocumented)
+    readonly errorType = DriverErrorType.deltaStreamConnectionForbidden;
+    // (undocumented)
+    readonly storageOnlyReason: string | undefined;
+}
+
+// @internal (undocumented)
+export class DocumentStorageServiceProxy implements IDocumentStorageService {
+    constructor(internalStorageService: IDocumentStorageService);
+    // (undocumented)
+    createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse>;
+    // (undocumented)
+    downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree>;
+    // (undocumented)
+    getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null>;
+    // (undocumented)
+    getVersions(versionId: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<IVersion[]>;
+    // (undocumented)
+    protected readonly internalStorageService: IDocumentStorageService;
+    set policies(policies: IDocumentStorageServicePolicies | undefined);
+    // (undocumented)
+    get policies(): IDocumentStorageServicePolicies | undefined;
+    // (undocumented)
+    readBlob(blobId: string): Promise<ArrayBufferLike>;
+    // (undocumented)
+    get repositoryUrl(): string;
+    // (undocumented)
+    uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string>;
+}
+
+// @internal
+export type DriverErrorTelemetryProps = ITelemetryProperties & {
+    driverVersion: string | undefined;
+};
+
+// @internal (undocumented)
+export const emptyMessageStream: IStream<ISequencedDocumentMessage[]>;
+
+// @internal
+export class FluidInvalidSchemaError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
+    constructor(message: string, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry = false;
+    // (undocumented)
+    readonly errorType = DriverErrorType.fluidInvalidSchema;
+}
+
+// @internal
+export class GenericNetworkError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
+    constructor(message: string, canRetry: boolean, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry: boolean;
+    // (undocumented)
+    readonly errorType = DriverErrorType.genericNetworkError;
+}
+
+// @internal
+export function getDocAttributesFromProtocolSummary(protocolSummary: ISummaryTree): IDocumentAttributes;
+
+// @internal
+export function getQuorumValuesFromProtocolSummary(protocolSummary: ISummaryTree): [string, ICommittedProposal][];
+
+// @internal
+export const getRetryDelayFromError: (error: any) => number | undefined;
+
+// @internal
+export const getRetryDelaySecondsFromError: (error: any) => number | undefined;
+
+// @public (undocumented)
+export interface ICompressionStorageConfig {
+    // (undocumented)
+    algorithm: SummaryCompressionAlgorithm;
+    // (undocumented)
+    minSizeToCompress: number;
+}
+
+// @internal
+export class InsecureUrlResolver implements IUrlResolver {
+    constructor(hostUrl: string, ordererUrl: string, storageUrl: string, tenantId: string, bearer: string, isForNodeTest?: boolean);
+    // (undocumented)
+    createCreateNewRequest(fileName?: string): IRequest;
+    // (undocumented)
+    getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string>;
+    // (undocumented)
+    resolve(request: IRequest): Promise<IResolvedUrl | undefined>;
+}
+
+// @internal
+export interface IProgress {
+    cancel?: AbortSignal;
+    onRetry?(delayInMs: number, error: any): void;
+}
+
+// @internal
+export function isCombinedAppAndProtocolSummary(summary: ISummaryTree | undefined, ...optionalRootTrees: string[]): summary is CombinedAppAndProtocolSummary;
+
+// @internal
+export function isOnline(): OnlineStatus;
+
+// @internal
+export function isRuntimeMessage(message: {
+    type: string;
+}): boolean;
+
+// @internal (undocumented)
+export class LocationRedirectionError extends LoggingError implements ILocationRedirectionError, IFluidErrorBase {
+    constructor(message: string, redirectUrl: IResolvedUrl, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry = false;
+    // (undocumented)
+    readonly errorType = DriverErrorType.locationRedirection;
+    // (undocumented)
+    readonly redirectUrl: IResolvedUrl;
+}
+
+// @internal (undocumented)
+export function logNetworkFailure(logger: ITelemetryLoggerExt, event: ITelemetryErrorEvent, error?: any): void;
+
+// @internal (undocumented)
+export enum MessageType2 {
+    // (undocumented)
+    Accept = "accept"
+}
+
+// @internal (undocumented)
+export class NetworkErrorBasic<T extends string> extends LoggingError implements IFluidErrorBase {
+    constructor(message: string, errorType: T, canRetry: boolean, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry: boolean;
+    // (undocumented)
+    readonly errorType: T;
+}
+
+// @internal (undocumented)
+export class NonRetryableError<T extends string> extends NetworkErrorBasic<T> {
+    constructor(message: string, errorType: T, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly errorType: T;
+}
+
+// @internal (undocumented)
+export enum OnlineStatus {
+    // (undocumented)
+    Offline = 0,
+    // (undocumented)
+    Online = 1,
+    // (undocumented)
+    Unknown = 2
+}
+
+// @internal
+export class ParallelRequests<T> {
+    constructor(from: number, to: number | undefined, payloadSize: number, logger: ITelemetryLoggerExt, requestCallback: (request: number, from: number, to: number, strongTo: boolean, props: ITelemetryProperties) => Promise<{
+        partial: boolean;
+        cancel: boolean;
+        payload: T[];
+    }>, responseCallback: (payload: T[]) => void);
+    // (undocumented)
+    cancel(): void;
+    // (undocumented)
+    get canceled(): boolean;
+    // (undocumented)
+    run(concurrency: number): Promise<void>;
+}
+
+// @internal (undocumented)
+export class PrefetchDocumentStorageService extends DocumentStorageServiceProxy {
+    // (undocumented)
+    getSnapshotTree(version?: IVersion): Promise<ISnapshotTree | null>;
+    // (undocumented)
+    get policies(): {
+        caching: LoaderCachingPolicy;
+        maximumCacheDurationMs?: 432000000 | undefined;
+    } | undefined;
+    // (undocumented)
+    readBlob(blobId: string): Promise<ArrayBufferLike>;
+    // (undocumented)
+    stopPrefetch(): void;
+}
+
+// @internal
+export class Queue<T> implements IStream<T> {
+    // (undocumented)
+    protected pushCore(value: Promise<IStreamResult<T>>): void;
+    // (undocumented)
+    pushDone(): void;
+    // (undocumented)
+    pushError(error: any): void;
+    // (undocumented)
+    pushValue(value: T): void;
+    // (undocumented)
+    read(): Promise<IStreamResult<T>>;
+}
+
+// @alpha (undocumented)
+export class RateLimiter {
+    constructor(maxRequests: number);
+    // (undocumented)
+    protected acquire(): Promise<void>;
+    // (undocumented)
+    protected readonly release: () => void;
+    // (undocumented)
+    schedule<T>(work: () => Promise<T>): Promise<T>;
+    // (undocumented)
+    get waitQueueLength(): number;
+}
+
+// @internal
+export function readAndParse<T>(storage: Pick<IDocumentStorageService, "readBlob">, id: string): Promise<T>;
+
+// @internal
+export function requestOps(get: (from: number, to: number, telemetryProps: ITelemetryProperties) => Promise<IDeltasFetchResult>, concurrency: number, fromTotal: number, toTotal: number | undefined, payloadSize: number, logger: ITelemetryLoggerExt, signal?: AbortSignal, scenarioName?: string): IStream<ISequencedDocumentMessage[]>;
+
+// @internal (undocumented)
+export class RetryableError<T extends string> extends NetworkErrorBasic<T> {
+    constructor(message: string, errorType: T, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly errorType: T;
+}
+
+// @internal (undocumented)
+export function runWithRetry<T>(api: (cancel?: AbortSignal) => Promise<T>, fetchCallName: string, logger: ITelemetryLoggerExt, progress: IProgress): Promise<T>;
+
+// @internal (undocumented)
+export function streamFromMessages(messagesArg: Promise<ISequencedDocumentMessage[]>): IStream<ISequencedDocumentMessage[]>;
+
+// @internal (undocumented)
+export function streamObserver<T>(stream: IStream<T>, handler: (value: IStreamResult<T>) => void): IStream<T>;
+
+// @public (undocumented)
+export enum SummaryCompressionAlgorithm {
+    // (undocumented)
+    LZ4 = 1,
+    // (undocumented)
+    None = 0
+}
+
+// @internal
+export class ThrottlingError extends LoggingError implements IThrottlingWarning, IFluidErrorBase {
+    constructor(message: string, retryAfterSeconds: number, props: DriverErrorTelemetryProps);
+    // (undocumented)
+    readonly canRetry = true;
+    // (undocumented)
+    readonly errorType = DriverErrorType.throttlingError;
+    // (undocumented)
+    readonly retryAfterSeconds: number;
+}
+
+// @internal
+export class TreeTreeEntry {
+    constructor(path: string, value: ITree);
+    // (undocumented)
+    readonly mode = FileMode.Directory;
+    // (undocumented)
+    readonly path: string;
+    // (undocumented)
+    readonly type = TreeEntry.Tree;
+    // (undocumented)
+    readonly value: ITree;
+}
+
+// @internal
+export class UsageError extends LoggingError implements IDriverErrorBase, IFluidErrorBase {
+    constructor(message: string);
+    // (undocumented)
+    readonly canRetry = false;
+    // (undocumented)
+    readonly errorType = DriverErrorType.usageError;
+}
+
+// (No @packageDocumentation comment for this package)
+
+```