## API Report File for "@fluidframework/protocol-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";

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

// @internal @deprecated (undocumented)
export interface IActorClient {
    // (undocumented)
    sub: string;
}

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

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

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

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

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

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

// @public
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;
}

// @internal
export interface IClientJoin {
    clientId: string;
    detail: IClient;
}

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

// @internal
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[];
}

// @alpha
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;
}

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

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

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

// @internal
export interface IDocumentSystemMessage extends IDocumentMessage {
    // (undocumented)
    data: string;
}

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

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

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

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

// @internal (undocumented)
export interface IProtocolState {
    // (undocumented)
    members: [string, ISequencedClient][];
    // (undocumented)
    minimumSequenceNumber: number;
    // (undocumented)
    proposals: [number, ISequencedProposal, string[]][];
    // (undocumented)
    sequenceNumber: number;
    // (undocumented)
    values: [string, ICommittedProposal][];
}

// @alpha
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"];
}

// @internal @deprecated (undocumented)
export interface IQuorumClientsEvents {
    // (undocumented)
    (event: "addMember", listener: (clientId: string, details: ISequencedClient) => void): any;
    // (undocumented)
    (event: "removeMember", listener: (clientId: string) => void): any;
    // (undocumented)
    (event: "error", listener: (message: any) => void): any;
}

// @internal @deprecated
export type IQuorumEvents = IQuorumClientsEvents & IQuorumProposalsEvents;

// @alpha
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>;
}

// @internal @deprecated
export interface IQuorumProposalsEvents {
    // (undocumented)
    (event: "addProposal", listener: (proposal: ISequencedProposal) => void): any;
    // (undocumented)
    (event: "approveProposal", listener: (sequenceNumber: number, key: string, value: unknown, approvalSequenceNumber: number) => void): any;
    // (undocumented)
    (event: "error", listener: (message: any) => void): void;
}

// @internal
export type ISentSignalMessage = ISignalMessageBase;

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

// @internal (undocumented)
export interface ISequencedDocumentAugmentedMessage extends ISequencedDocumentMessage {
    // (undocumented)
    additionalContent: string;
}

// @public
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;
}

// @internal
export type ISequencedDocumentMessageExperimental = Omit<ISequencedDocumentMessage, "expHash1" | "compression"> & {
    expHash1?: string;
    compression?: string;
};

// @internal (undocumented)
export interface ISequencedDocumentSystemMessage extends ISequencedDocumentMessage {
    // (undocumented)
    data: string;
}

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

// @internal
export interface IServerError {
    errorMessage: string;
}

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

// @public
export interface ISignalMessage extends ISignalMessageBase {
    clientId: string | null;
}

// @public
export interface ISignalMessageBase {
    clientConnectionNumber?: number;
    content: unknown;
    referenceSequenceNumber?: number;
    targetClientId?: string;
    type?: string;
}

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

// @internal (undocumented)
export interface ISnapshotTreeEx extends ISnapshotTree {
    // (undocumented)
    id: string;
    // (undocumented)
    trees: {
        [path: string]: ISnapshotTreeEx;
    };
}

// @alpha
export type IsoDate = string;

// @alpha
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;
}

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

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

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

// @alpha
export interface ISummaryProposal {
    summarySequenceNumber: number;
}

// @internal @deprecated (undocumented)
export interface ISummaryTokenClaims {
    // (undocumented)
    act: IActorClient;
    // (undocumented)
    claims: ITokenClaims;
    // (undocumented)
    sub: string;
}

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

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

// @internal @deprecated (undocumented)
export interface ITokenProvider {
    isValid(): boolean;
}

// @internal @deprecated (undocumented)
export interface ITokenService {
    // (undocumented)
    extractClaims(token: string): ITokenClaims;
}

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

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

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

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

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

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

// @alpha (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"
}

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

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

// @internal (undocumented)
export enum SignalType {
    ClientJoin = "join",
    ClientLeave = "leave"
}

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

// @alpha
export type SummaryTree = ISummaryTree | ISummaryHandle;

// @public
export namespace SummaryType {
    // @internal (undocumented)
    export type Attachment = 4;
    // @internal (undocumented)
    export type Blob = 2;
    // @internal (undocumented)
    export type Handle = 3;
    // @internal (undocumented)
    export type Tree = 1;
    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;

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

```