## Beta API Report File for "@fluidframework/driver-definitions"

> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).

```ts

// @public
export type ConnectionMode = "write" | "read";

// @beta @legacy (undocumented)
export type DriverError = IThrottlingWarning | IGenericNetworkError | IAuthorizationError | ILocationRedirectionError | IDriverBasicError;

// @beta @legacy
export const DriverErrorTypes: {
    readonly genericNetworkError: "genericNetworkError";
    readonly authorizationError: "authorizationError";
    readonly fileNotFoundOrAccessDeniedError: "fileNotFoundOrAccessDeniedError";
    readonly offlineError: "offlineError";
    readonly unsupportedClientProtocolVersion: "unsupportedClientProtocolVersion";
    readonly writeError: "writeError";
    readonly fetchFailure: "fetchFailure";
    readonly fetchTokenError: "fetchTokenError";
    readonly incorrectServerResponse: "incorrectServerResponse";
    readonly fileOverwrittenInStorage: "fileOverwrittenInStorage";
    readonly deltaStreamConnectionForbidden: "deltaStreamConnectionForbidden";
    readonly locationRedirection: "locationRedirection";
    readonly fluidInvalidSchema: "fluidInvalidSchema";
    readonly fileIsLocked: "fileIsLocked";
    readonly outOfStorageError: "outOfStorageError";
    readonly genericError: "genericError";
    readonly throttlingError: "throttlingError";
    readonly usageError: "usageError";
    readonly layerIncompatibilityError: "layerIncompatibilityError";
};

// @beta @legacy
export type DriverErrorTypes = (typeof DriverErrorTypes)[keyof typeof DriverErrorTypes];

// @beta @legacy
export enum DriverHeader {
    // (undocumented)
    createNew = "createNew",
    // (undocumented)
    summarizingClient = "fluid-client-summarizer"
}

// @beta @legacy
export interface DriverPreCheckInfo {
    codeDetailsHint?: string;
    criticalBootDomains?: string[];
}

// @beta @legacy (undocumented)
export enum FetchSource {
    // (undocumented)
    default = "default",
    // (undocumented)
    noCache = "noCache"
}

// @beta @legacy (undocumented)
export enum FileMode {
    // (undocumented)
    Directory = "040000",
    // (undocumented)
    Executable = "100755",
    // (undocumented)
    File = "100644",
    // (undocumented)
    Symlink = "120000"
}

// @beta @legacy (undocumented)
export type FiveDaysMs = 432_000_000;

// @beta @legacy
export interface IAnyDriverError extends Omit<IDriverErrorBase, "errorType"> {
    // (undocumented)
    readonly errorType: string;
    scenarioName?: string;
}

// @beta @legacy
export type IApprovedProposal = {
    approvalSequenceNumber: number;
} & ISequencedProposal;

// @beta @legacy (undocumented)
export interface IAttachment {
    // (undocumented)
    id: string;
}

// @beta @legacy (undocumented)
export interface IAuthorizationError extends IDriverErrorBase {
    // (undocumented)
    readonly claims?: string;
    // (undocumented)
    readonly errorType: typeof DriverErrorTypes.authorizationError;
    // (undocumented)
    readonly tenantId?: string;
}

// @beta @legacy
export interface IBlob {
    contents: string;
    encoding: "utf-8" | "base64";
}

// @beta @legacy
export interface IBranchOrigin {
    id: string;
    minimumSequenceNumber: number;
    sequenceNumber: number;
}

// @beta @legacy
export interface ICacheEntry extends IEntry {
    file: IFileEntry;
}

// @public
export interface ICapabilities {
    interactive: boolean;
}

// @public
export interface IClient {
    details: IClientDetails;
    mode: ConnectionMode;
    // (undocumented)
    permission: string[];
    scopes: string[];
    timestamp?: number;
    user: IUser;
}

// @beta @legacy
export interface IClientConfiguration {
    blockSize: number;
    maxMessageSize: number;
    noopCountFrequency?: number;
    noopTimeFrequency?: number;
}

// @public
export interface IClientDetails {
    capabilities: ICapabilities;
    // (undocumented)
    device?: string;
    // (undocumented)
    environment?: string;
    type?: string;
}

// @beta @legacy
export type ICommittedProposal = {
    commitSequenceNumber: number;
} & IApprovedProposal;

// @beta @legacy
export interface IConnect {
    client: IClient;
    driverVersion?: string;
    epoch?: string;
    id: string;
    mode: ConnectionMode;
    nonce?: string;
    relayUserAgent?: string;
    supportedFeatures?: Record<string, unknown>;
    tenantId: string;
    token: string | null;
    versions: string[];
}

// @beta @legacy
export interface IConnected {
    checkpointSequenceNumber?: number;
    claims: ITokenClaims;
    clientId: string;
    epoch?: string;
    existing: boolean;
    initialClients: ISignalClient[];
    initialMessages: ISequencedDocumentMessage[];
    initialSignals: ISignalMessage[];
    maxMessageSize: number;
    mode: ConnectionMode;
    nonce?: string;
    relayServiceAgent?: string;
    serviceConfiguration: IClientConfiguration;
    supportedFeatures?: Record<string, unknown>;
    supportedVersions: string[];
    timestamp?: number;
    version: string;
}

// @beta @legacy
export interface IContainerPackageInfo {
    name: string;
}

// @beta @legacy (undocumented)
export interface ICreateBlobResponse {
    // (undocumented)
    id: string;
}

// @beta @legacy (undocumented)
export interface IDocumentAttributes {
    minimumSequenceNumber: number;
    sequenceNumber: number;
}

// @beta @legacy (undocumented)
export interface IDocumentDeltaConnection extends IDisposable, IEventProvider<IDocumentDeltaConnectionEvents> {
    checkpointSequenceNumber?: number;
    claims: ITokenClaims;
    clientId: string;
    existing: boolean;
    initialClients: ISignalClient[];
    initialMessages: ISequencedDocumentMessage[];
    initialSignals: ISignalMessage[];
    mode: ConnectionMode;
    relayServiceAgent?: string;
    serviceConfiguration: IClientConfiguration;
    submit(messages: IDocumentMessage[]): void;
    submitSignal: (content: string, targetClientId?: string) => void;
    version: string;
}

// @beta @legacy (undocumented)
export interface IDocumentDeltaConnectionEvents extends IErrorEvent {
    // (undocumented)
    (event: "nack", listener: (documentId: string, message: INack[]) => void): any;
    // (undocumented)
    (event: "disconnect", listener: (reason: IAnyDriverError) => void): any;
    // (undocumented)
    (event: "op", listener: (documentId: string, messages: ISequencedDocumentMessage[]) => void): any;
    // (undocumented)
    (event: "signal", listener: (message: ISignalMessage | ISignalMessage[]) => void): any;
    // (undocumented)
    (event: "pong", listener: (latency: number) => void): any;
    // (undocumented)
    (event: "error", listener: (error: any) => void): any;
}

// @beta @legacy
export interface IDocumentDeltaStorageService {
    fetchMessages(from: number, to: number | undefined, abortSignal?: AbortSignal, cachedOnly?: boolean, fetchReason?: string): IStream<ISequencedDocumentMessage[]>;
}

// @beta @legacy
export interface IDocumentMessage {
    clientSequenceNumber: number;
    compression?: string;
    contents: unknown;
    metadata?: unknown;
    referenceSequenceNumber: number;
    serverMetadata?: unknown;
    traces?: ITrace[];
    type: string;
}

// @beta @legacy (undocumented)
export interface IDocumentService extends IEventProvider<IDocumentServiceEvents> {
    connectToDeltaStorage(): Promise<IDocumentDeltaStorageService>;
    connectToDeltaStream(client: IClient): Promise<IDocumentDeltaConnection>;
    connectToStorage(): Promise<IDocumentStorageService>;
    dispose(error?: any): void;
    policies?: IDocumentServicePolicies | undefined;
    // (undocumented)
    resolvedUrl: IResolvedUrl;
}

// @beta @legacy
export interface IDocumentServiceEvents extends IEvent {
    (event: "metadataUpdate", listener: (metadata: Record<string, string>) => void): any;
}

// @beta @legacy (undocumented)
export interface IDocumentServiceFactory {
    createContainer(createNewSummary: ISummaryTree | undefined, createNewResolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
    createDocumentService(resolvedUrl: IResolvedUrl, logger?: ITelemetryBaseLogger, clientIsSummarizer?: boolean): Promise<IDocumentService>;
}

// @beta @legacy (undocumented)
export interface IDocumentServicePolicies {
    readonly storageOnly?: boolean;
    readonly summarizeProtocolTree?: boolean;
    readonly supportGetSnapshotApi?: boolean;
}

// @beta @legacy
export interface IDocumentStorageService extends Partial<IDisposable> {
    createBlob(file: ArrayBufferLike): Promise<ICreateBlobResponse>;
    downloadSummary(handle: ISummaryHandle): Promise<ISummaryTree>;
    getSnapshot?(snapshotFetchOptions?: ISnapshotFetchOptions): Promise<ISnapshot>;
    getSnapshotTree(version?: IVersion, scenarioName?: string): Promise<ISnapshotTree | null>;
    getVersions(versionId: string | null, count: number, scenarioName?: string, fetchSource?: FetchSource): Promise<IVersion[]>;
    readonly policies?: IDocumentStorageServicePolicies | undefined;
    readBlob(id: string): Promise<ArrayBufferLike>;
    uploadSummaryWithContext(summary: ISummaryTree, context: ISummaryContext): Promise<string>;
}

// @beta @legacy
export interface IDocumentStorageServicePolicies {
    readonly caching?: LoaderCachingPolicy;
    readonly maximumCacheDurationMs?: FiveDaysMs;
}

// @beta @legacy
export interface IDriverBasicError extends IDriverErrorBase {
    // (undocumented)
    readonly errorType: typeof DriverErrorTypes.genericError | typeof DriverErrorTypes.fileNotFoundOrAccessDeniedError | typeof DriverErrorTypes.offlineError | typeof DriverErrorTypes.unsupportedClientProtocolVersion | typeof DriverErrorTypes.writeError | typeof DriverErrorTypes.fetchFailure | typeof DriverErrorTypes.fetchTokenError | typeof DriverErrorTypes.incorrectServerResponse | typeof DriverErrorTypes.fileOverwrittenInStorage | typeof DriverErrorTypes.fluidInvalidSchema | typeof DriverErrorTypes.usageError | typeof DriverErrorTypes.fileIsLocked | typeof DriverErrorTypes.outOfStorageError;
    // (undocumented)
    readonly statusCode?: number;
}

// @beta @legacy
export interface IDriverErrorBase {
    canRetry: boolean;
    endpointReached?: boolean;
    readonly errorType: DriverErrorTypes;
    readonly message: string;
    online?: string;
}

// @beta @legacy
export interface IEntry {
    key: string;
    type: string;
}

// @beta @legacy
export interface IFileEntry {
    docId: string;
    fileVersion?: string;
    resolvedUrl: IResolvedUrl;
}

// @beta @legacy (undocumented)
export interface IGenericNetworkError extends IDriverErrorBase {
    // (undocumented)
    readonly errorType: typeof DriverErrorTypes.genericNetworkError;
    // (undocumented)
    readonly statusCode?: number;
}

// @beta @legacy (undocumented)
export interface ILocationRedirectionError extends IDriverErrorBase {
    // (undocumented)
    readonly errorType: typeof DriverErrorTypes.locationRedirection;
    // (undocumented)
    readonly redirectUrl: IResolvedUrl;
}

// @beta @legacy (undocumented)
export interface INack {
    content: INackContent;
    operation: IDocumentMessage | undefined;
    sequenceNumber: number;
}

// @beta @legacy
export interface INackContent {
    code: number;
    message: string;
    retryAfter?: number;
    type: NackErrorType;
}

// @beta @legacy
export interface IPersistedCache {
    get(entry: ICacheEntry): Promise<unknown>;
    put(entry: ICacheEntry, value: unknown): Promise<void>;
    removeEntries(file: IFileEntry): Promise<void>;
    removeEntry?(entry: ICacheEntry): Promise<void>;
    update?(entry: ICacheEntry, updater: (existing: unknown, set: (value: unknown) => void) => void): Promise<boolean>;
}

// @beta @legacy (undocumented)
export interface IProcessMessageResult {
    // (undocumented)
    immediateNoOp?: boolean;
}

// @beta @legacy
export interface IProposal {
    key: string;
    value: unknown;
}

// @beta @legacy
export interface IQuorum extends Omit<IQuorumClients, "on" | "once" | "off">, Omit<IQuorumProposals, "on" | "once" | "off"> {
    // (undocumented)
    off: IQuorum["on"];
    // (undocumented)
    on: IQuorumClients["on"] & IQuorumProposals["on"];
    // (undocumented)
    once: IQuorum["on"];
}

// @public
export interface IQuorumClients {
    // (undocumented)
    getMember(clientId: string): ISequencedClient | undefined;
    // (undocumented)
    getMembers(): Map<string, ISequencedClient>;
    // (undocumented)
    off: IQuorumClients["on"];
    // (undocumented)
    on(event: "addMember", listener: (clientId: string, details: ISequencedClient) => void): any;
    // (undocumented)
    on(event: "removeMember", listener: (clientId: string) => void): any;
    // (undocumented)
    on(event: "error", listener: (message: any) => void): any;
    // (undocumented)
    once: IQuorumClients["on"];
}

// @beta @legacy
export interface IQuorumProposals {
    // (undocumented)
    get(key: string): unknown;
    // (undocumented)
    has(key: string): boolean;
    // (undocumented)
    off: IQuorumProposals["on"];
    // (undocumented)
    on(event: "addProposal", listener: (proposal: ISequencedProposal) => void): any;
    // (undocumented)
    on(event: "approveProposal", listener: (sequenceNumber: number, key: string, value: unknown, approvalSequenceNumber: number) => void): any;
    // (undocumented)
    on(event: "error", listener: (message: any) => void): void;
    // (undocumented)
    once: IQuorumProposals["on"];
    // (undocumented)
    propose(key: string, value: unknown): Promise<void>;
}

// @beta @legacy (undocumented)
export interface IResolvedUrl {
    // (undocumented)
    endpoints: {
        [name: string]: string;
    };
    id: string;
    // (undocumented)
    tokens: {
        [name: string]: string;
    };
    // (undocumented)
    type: "fluid";
    // (undocumented)
    url: string;
}

// @public
export interface ISequencedClient {
    client: IClient;
    sequenceNumber: number;
}

// @beta @legacy
export interface ISequencedDocumentMessage {
    clientId: string | null;
    clientSequenceNumber: number;
    // @deprecated
    compression?: string;
    contents: unknown;
    data?: string;
    // @deprecated
    expHash1?: string;
    metadata?: unknown;
    minimumSequenceNumber: number;
    origin?: IBranchOrigin;
    referenceSequenceNumber: number;
    sequenceNumber: number;
    serverMetadata?: unknown;
    timestamp: number;
    traces?: ITrace[];
    type: string;
}

// @beta @legacy
export type ISequencedProposal = {
    sequenceNumber: number;
} & IProposal;

// @beta @legacy (undocumented)
export interface ISignalClient {
    client: IClient;
    clientConnectionNumber?: number;
    clientId: string;
    referenceSequenceNumber?: number;
}

// @beta @legacy
export interface ISignalMessage<TMessage extends TypedMessage = TypedMessage> extends ISignalMessageBase<TMessage> {
    clientId: string | null;
}

// @beta @legacy
export interface ISignalMessageBase<TMessage extends TypedMessage = TypedMessage> {
    clientConnectionNumber?: number;
    content: TMessage["content"];
    referenceSequenceNumber?: number;
    targetClientId?: string;
    type?: TMessage["type"];
}

// @beta @legacy
export interface ISnapshot {
    // (undocumented)
    blobContents: Map<string, ArrayBuffer>;
    latestSequenceNumber: number | undefined;
    // (undocumented)
    ops: ISequencedDocumentMessage[];
    sequenceNumber: number | undefined;
    // (undocumented)
    snapshotFormatV: 1;
    // (undocumented)
    snapshotTree: ISnapshotTree;
}

// @beta @legacy
export interface ISnapshotFetchOptions {
    cacheSnapshot?: boolean;
    fetchSource?: FetchSource;
    loadingGroupIds?: string[];
    scenarioName?: string;
    versionId?: string;
}

// @beta @legacy (undocumented)
export interface ISnapshotTree {
    // (undocumented)
    blobs: {
        [path: string]: string;
    };
    groupId?: string;
    // (undocumented)
    id?: string;
    // (undocumented)
    trees: {
        [path: string]: ISnapshotTree;
    };
    unreferenced?: true;
}

// @beta @legacy
export type IsoDate = string;

// @beta @legacy
export interface IStream<T> {
    // (undocumented)
    read(): Promise<IStreamResult<T>>;
}

// @beta @legacy (undocumented)
export type IStreamResult<T> = {
    done: true;
} | {
    done: false;
    value: T;
};

// @beta @legacy
export interface ISummaryAck {
    handle: string;
    summaryProposal: ISummaryProposal;
}

// @public
export interface ISummaryAttachment {
    // (undocumented)
    id: string;
    // (undocumented)
    type: SummaryType.Attachment;
}

// @public
export interface ISummaryBlob {
    // (undocumented)
    content: string | Uint8Array;
    // (undocumented)
    type: SummaryType.Blob;
}

// @beta @legacy (undocumented)
export interface ISummaryContent {
    details?: IUploadedSummaryDetails;
    handle: string;
    head: string;
    message: string;
    parents: string[];
}

// @beta @legacy
export interface ISummaryContext {
    readonly ackHandle: string | undefined;
    readonly proposalHandle: string | undefined;
    // (undocumented)
    readonly referenceSequenceNumber: number;
}

// @public
export interface ISummaryHandle {
    handle: string;
    handleType: SummaryTypeNoHandle;
    // (undocumented)
    type: SummaryType.Handle;
}

// @beta @legacy
export interface ISummaryNack {
    code?: number;
    message?: string;
    retryAfter?: number;
    summaryProposal: ISummaryProposal;
}

// @beta @legacy
export interface ISummaryProposal {
    summarySequenceNumber: number;
}

// @public
export interface ISummaryTree {
    groupId?: string;
    tree: {
        [path: string]: SummaryObject;
    };
    // (undocumented)
    type: SummaryType.Tree;
    unreferenced?: true;
}

// @beta @legacy (undocumented)
export interface IThrottlingWarning extends IDriverErrorBase {
    // (undocumented)
    readonly errorType: typeof DriverErrorTypes.throttlingError;
    // (undocumented)
    readonly retryAfterSeconds: number;
}

// @beta @legacy
export interface ITokenClaims {
    documentId: string;
    exp: number;
    iat: number;
    jti?: string;
    scopes: string[];
    tenantId: string;
    user: IUser;
    ver: string;
}

// @beta @legacy
export interface ITrace {
    action: string;
    service: string;
    timestamp: number;
}

// @beta @legacy (undocumented)
export interface ITree {
    // (undocumented)
    entries: ITreeEntry[];
    groupId?: string;
    id?: string;
    unreferenced?: true;
}

// @beta @legacy
export type ITreeEntry = {
    path: string;
    mode: FileMode;
} & ({
    type: TreeEntry.Blob;
    value: IBlob;
} | {
    type: TreeEntry.Tree;
    value: ITree;
} | {
    type: TreeEntry.Attachment;
    value: IAttachment;
});

// @beta @legacy (undocumented)
export interface IUploadedSummaryDetails {
    includesProtocolTree?: boolean;
}

// @beta @legacy (undocumented)
export interface IUrlResolver {
    getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string, packageInfoSource?: IContainerPackageInfo): Promise<string>;
    // (undocumented)
    resolve(request: IRequest): Promise<IResolvedUrl | undefined>;
}

// @public
export interface IUser {
    id: string;
}

// @beta @legacy
export interface IVersion {
    date?: IsoDate;
    id: string;
    treeId: string;
}

// @beta @legacy (undocumented)
export enum LoaderCachingPolicy {
    NoCaching = 0,
    Prefetch = 1
}

// @beta @legacy (undocumented)
export enum MessageType {
    Accept = "accept",
    ClientJoin = "join",
    ClientLeave = "leave",
    Control = "control",
    NoClient = "noClient",
    NoOp = "noop",
    Operation = "op",
    Propose = "propose",
    Reject = "reject",
    RoundTrip = "tripComplete",
    Summarize = "summarize",
    SummaryAck = "summaryAck",
    SummaryNack = "summaryNack"
}

// @beta @legacy
export enum NackErrorType {
    BadRequestError = "BadRequestError",
    InvalidScopeError = "InvalidScopeError",
    LimitExceededError = "LimitExceededError",
    ThrottlingError = "ThrottlingError"
}

// @beta @legacy
export enum ScopeType {
    DocRead = "doc:read",
    DocWrite = "doc:write",
    SummaryWrite = "summary:write"
}

// @public
export type SummaryObject = ISummaryTree | ISummaryBlob | ISummaryHandle | ISummaryAttachment;

// @beta @legacy
export type SummaryTree = ISummaryTree | ISummaryHandle;

// @public
export namespace SummaryType {
    const Tree: Tree;
    const Blob: Blob;
    const Handle: Handle;
    const Attachment: Attachment;
}

// @public
export type SummaryType = SummaryType.Attachment | SummaryType.Blob | SummaryType.Handle | SummaryType.Tree;

// @public
export type SummaryTypeNoHandle = SummaryType.Tree | SummaryType.Blob | SummaryType.Attachment;

// @beta @legacy
export enum TreeEntry {
    // (undocumented)
    Attachment = "Attachment",
    // (undocumented)
    Blob = "Blob",
    // (undocumented)
    Tree = "Tree"
}

// (No @packageDocumentation comment for this package)

```