@hocuspocus/provider 3.4.3 → 3.4.5-rc.0

package/dist/packages/provider/src/HocuspocusProvider.d.ts

@@ -1,116 +0,0 @@
-import type { Event, MessageEvent } from "ws";
-import { Awareness } from "y-protocols/awareness";
-import * as Y from "yjs";
-import EventEmitter from "./EventEmitter.ts";
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from "./HocuspocusProviderWebsocket.ts";
-import { HocuspocusProviderWebsocket } from "./HocuspocusProviderWebsocket.ts";
-import type { ConstructableOutgoingMessage, onAuthenticatedParameters, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, onUnsyncedChangesParameters } from "./types.ts";
-export type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, "name">> & Partial<CompleteHocuspocusProviderConfiguration> & (Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> | Required<Pick<CompleteHocuspocusProviderConfiguration, "websocketProvider">>);
-export interface CompleteHocuspocusProviderConfiguration {
-    /**
-     * The identifier/name of your document
-     */
-    name: string;
-    /**
-     * The actual Y.js document
-     */
-    document: Y.Doc;
-    /**
-     * An Awareness instance to keep the presence state of all clients.
-     *
-     * You can disable sharing awareness information by passing `null`.
-     * Note that having no awareness information shared across all connections will break our ping checks
-     * and thus trigger reconnects. You should always have at least one Provider with enabled awareness per
-     * socket connection, or ensure that the Provider receives messages before running into `HocuspocusProviderWebsocket.messageReconnectTimeout`.
-     */
-    awareness: Awareness | null;
-    /**
-     * A token that’s sent to the backend for authentication purposes.
-     */
-    token: string | (() => string) | (() => Promise<string>) | null;
-    /**
-     * Hocuspocus websocket provider
-     */
-    websocketProvider: HocuspocusProviderWebsocket;
-    /**
-     * Force syncing the document in the defined interval.
-     */
-    forceSyncInterval: false | number;
-    onAuthenticated: (data: onAuthenticatedParameters) => void;
-    onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
-    onOpen: (data: onOpenParameters) => void;
-    onConnect: () => void;
-    onStatus: (data: onStatusParameters) => void;
-    onMessage: (data: onMessageParameters) => void;
-    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
-    onSynced: (data: onSyncedParameters) => void;
-    onDisconnect: (data: onDisconnectParameters) => void;
-    onClose: (data: onCloseParameters) => void;
-    onDestroy: () => void;
-    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
-    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
-    onStateless: (data: onStatelessParameters) => void;
-    onUnsyncedChanges: (data: onUnsyncedChangesParameters) => void;
-}
-export declare class AwarenessError extends Error {
-    code: number;
-}
-export declare class HocuspocusProvider extends EventEmitter {
-    configuration: CompleteHocuspocusProviderConfiguration;
-    isSynced: boolean;
-    unsyncedChanges: number;
-    isAuthenticated: boolean;
-    authorizedScope: string | undefined;
-    manageSocket: boolean;
-    private _isAttached;
-    intervals: any;
-    constructor(configuration: HocuspocusProviderConfiguration);
-    boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
-    boundAwarenessUpdateHandler: ({ added, updated, removed }: any, origin: any) => void;
-    boundPageHide: () => void;
-    boundOnOpen: (event: Event) => Promise<void>;
-    boundOnClose: () => void;
-    forwardConnect: () => this;
-    forwardStatus: (e: onStatusParameters) => this;
-    forwardClose: (e: onCloseParameters) => this;
-    forwardDisconnect: (e: onDisconnectParameters) => this;
-    forwardDestroy: () => this;
-    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
-    get document(): Y.Doc;
-    get isAttached(): boolean;
-    get awareness(): Awareness | null;
-    get hasUnsyncedChanges(): boolean;
-    private resetUnsyncedChanges;
-    incrementUnsyncedChanges(): void;
-    decrementUnsyncedChanges(): void;
-    forceSync(): void;
-    pageHide(): void;
-    registerEventListeners(): void;
-    sendStateless(payload: string): void;
-    sendToken(): Promise<void>;
-    documentUpdateHandler(update: Uint8Array, origin: any): void;
-    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
-    /**
-     * Indicates whether a first handshake with the server has been established
-     *
-     * Note: this does not mean all updates from the client have been persisted to the backend. For this,
-     * use `hasUnsyncedChanges`.
-     */
-    get synced(): boolean;
-    set synced(state: boolean);
-    receiveStateless(payload: string): void;
-    connect(): Promise<unknown>;
-    disconnect(): void;
-    onOpen(event: Event): Promise<void>;
-    getToken(): Promise<string | null>;
-    startSync(): void;
-    send(message: ConstructableOutgoingMessage, args: any): void;
-    onMessage(event: MessageEvent): void;
-    onClose(): void;
-    destroy(): void;
-    detach(): void;
-    attach(): void;
-    permissionDeniedHandler(reason: string): void;
-    authenticatedHandler(scope: string): void;
-    setAwarenessField(key: string, value: any): void;
-}

package/dist/packages/provider/src/HocuspocusProviderWebsocket.d.ts

@@ -1,114 +0,0 @@
-import type { Event, MessageEvent } from "ws";
-import EventEmitter from "./EventEmitter.ts";
-import type { HocuspocusProvider } from "./HocuspocusProvider.ts";
-import { WebSocketStatus, type onAwarenessChangeParameters, type onAwarenessUpdateParameters, type onCloseParameters, type onDisconnectParameters, type onMessageParameters, type onOpenParameters, type onOutgoingMessageParameters, type onStatusParameters } from "./types.ts";
-export type HocuspocusWebSocket = WebSocket & {
-    identifier: string;
-};
-export type HocusPocusWebSocket = HocuspocusWebSocket;
-export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
-export interface CompleteHocuspocusProviderWebsocketConfiguration {
-    /**
-     * Whether to connect automatically when creating the provider instance. Default=true
-     */
-    autoConnect: boolean;
-    /**
-     * URL of your @hocuspocus/server instance
-     */
-    url: string;
-    /**
-     * An optional WebSocket polyfill, for example for Node.js
-     */
-    WebSocketPolyfill: any;
-    /**
-     * Disconnect when no message is received for the defined amount of milliseconds.
-     */
-    messageReconnectTimeout: number;
-    /**
-     * The delay between each attempt in milliseconds. You can provide a factor to have the delay grow exponentially.
-     */
-    delay: number;
-    /**
-     * The initialDelay is the amount of time to wait before making the first attempt. This option should typically be 0 since you typically want the first attempt to happen immediately.
-     */
-    initialDelay: number;
-    /**
-     * The factor option is used to grow the delay exponentially.
-     */
-    factor: number;
-    /**
-     * The maximum number of attempts or 0 if there is no limit on number of attempts.
-     */
-    maxAttempts: number;
-    /**
-     * minDelay is used to set a lower bound of delay when jitter is enabled. This property has no effect if jitter is disabled.
-     */
-    minDelay: number;
-    /**
-     * The maxDelay option is used to set an upper bound for the delay when factor is enabled. A value of 0 can be provided if there should be no upper bound when calculating delay.
-     */
-    maxDelay: number;
-    /**
-     * If jitter is true then the calculated delay will be a random integer value between minDelay and the calculated delay for the current iteration.
-     */
-    jitter: boolean;
-    /**
-     * A timeout in milliseconds. If timeout is non-zero then a timer is set using setTimeout. If the timeout is triggered then future attempts will be aborted.
-     */
-    timeout: number;
-    handleTimeout: (() => Promise<unknown>) | null;
-    onOpen: (data: onOpenParameters) => void;
-    onConnect: () => void;
-    onMessage: (data: onMessageParameters) => void;
-    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
-    onStatus: (data: onStatusParameters) => void;
-    onDisconnect: (data: onDisconnectParameters) => void;
-    onClose: (data: onCloseParameters) => void;
-    onDestroy: () => void;
-    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
-    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
-    /**
-     * Map of attached providers keyed by documentName.
-     */
-    providerMap: Map<string, HocuspocusProvider>;
-}
-export declare class HocuspocusProviderWebsocket extends EventEmitter {
-    private messageQueue;
-    configuration: CompleteHocuspocusProviderWebsocketConfiguration;
-    webSocket: HocusPocusWebSocket | null;
-    webSocketHandlers: {
-        [key: string]: any;
-    };
-    shouldConnect: boolean;
-    status: WebSocketStatus;
-    lastMessageReceived: number;
-    identifier: number;
-    intervals: any;
-    connectionAttempt: {
-        resolve: (value?: any) => void;
-        reject: (reason?: any) => void;
-    } | null;
-    constructor(configuration: HocuspocusProviderWebsocketConfiguration);
-    receivedOnOpenPayload?: Event | undefined;
-    onOpen(event: Event): Promise<void>;
-    attach(provider: HocuspocusProvider): void;
-    detach(provider: HocuspocusProvider): void;
-    setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;
-    cancelWebsocketRetry?: () => void;
-    connect(): Promise<unknown>;
-    attachWebSocketListeners(ws: HocusPocusWebSocket, reject: Function): void;
-    cleanupWebSocket(): void;
-    createWebSocketConnection(): Promise<unknown>;
-    onMessage(event: MessageEvent): void;
-    resolveConnectionAttempt(): void;
-    stopConnectionAttempt(): void;
-    rejectConnectionAttempt(): void;
-    closeTries: number;
-    checkConnection(): void;
-    get serverUrl(): string;
-    get url(): string;
-    disconnect(): void;
-    send(message: any): void;
-    onClose({ event }: onCloseParameters): void;
-    destroy(): void;
-}

package/dist/packages/provider/src/IncomingMessage.d.ts

@@ -1,17 +0,0 @@
-import type { Decoder } from "lib0/decoding";
-import type { Encoder } from "lib0/encoding";
-import type { MessageType } from "./types.ts";
-export declare class IncomingMessage {
-    data: any;
-    encoder: Encoder;
-    decoder: Decoder;
-    constructor(data: any);
-    peekVarString(): string;
-    readVarUint(): MessageType;
-    readVarString(): string;
-    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
-    writeVarUint(type: MessageType): void;
-    writeVarString(string: string): void;
-    writeVarUint8Array(data: Uint8Array): void;
-    length(): number;
-}

package/dist/packages/provider/src/MessageReceiver.d.ts

@@ -1,12 +0,0 @@
-import type { HocuspocusProvider } from "./HocuspocusProvider.ts";
-import type { IncomingMessage } from "./IncomingMessage.ts";
-export declare class MessageReceiver {
-    message: IncomingMessage;
-    constructor(message: IncomingMessage);
-    apply(provider: HocuspocusProvider, emitSynced: boolean): void;
-    private applySyncMessage;
-    applySyncStatusMessage(provider: HocuspocusProvider, applied: boolean): void;
-    private applyAwarenessMessage;
-    private applyAuthMessage;
-    private applyQueryAwarenessMessage;
-}

package/dist/packages/provider/src/MessageSender.d.ts

@@ -1,9 +0,0 @@
-import type { Encoder } from "lib0/encoding";
-import type { ConstructableOutgoingMessage } from "./types.ts";
-export declare class MessageSender {
-    encoder: Encoder;
-    message: any;
-    constructor(Message: ConstructableOutgoingMessage, args?: any);
-    create(): Uint8Array<ArrayBufferLike>;
-    send(webSocket: any): void;
-}

package/dist/packages/provider/src/OutgoingMessage.d.ts

@@ -1,9 +0,0 @@
-import type { Encoder } from "lib0/encoding";
-import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from "./types.ts";
-export declare class OutgoingMessage implements OutgoingMessageInterface {
-    encoder: Encoder;
-    type?: MessageType;
-    constructor();
-    get(args: Partial<OutgoingMessageArguments>): Encoder | undefined;
-    toUint8Array(): Uint8Array<ArrayBufferLike>;
-}

package/dist/packages/provider/src/OutgoingMessages/AuthenticationMessage.d.ts

@@ -1,8 +0,0 @@
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class AuthenticationMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/AwarenessMessage.d.ts

@@ -1,9 +0,0 @@
-import * as encoding from "lib0/encoding";
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class AwarenessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/CloseMessage.d.ts

@@ -1,9 +0,0 @@
-import * as encoding from "lib0/encoding";
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class CloseMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/QueryAwarenessMessage.d.ts

@@ -1,9 +0,0 @@
-import * as encoding from "lib0/encoding";
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class QueryAwarenessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/StatelessMessage.d.ts

@@ -1,8 +0,0 @@
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class StatelessMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/SyncStepOneMessage.d.ts

@@ -1,9 +0,0 @@
-import * as encoding from "lib0/encoding";
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class SyncStepOneMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/SyncStepTwoMessage.d.ts

@@ -1,9 +0,0 @@
-import * as encoding from "lib0/encoding";
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class SyncStepTwoMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): encoding.Encoder;
-}

package/dist/packages/provider/src/OutgoingMessages/UpdateMessage.d.ts

@@ -1,8 +0,0 @@
-import type { OutgoingMessageArguments } from "../types.ts";
-import { MessageType } from "../types.ts";
-import { OutgoingMessage } from "../OutgoingMessage.ts";
-export declare class UpdateMessage extends OutgoingMessage {
-    type: MessageType;
-    description: string;
-    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
-}

package/dist/packages/provider/src/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./HocuspocusProvider.ts";
-export * from "./HocuspocusProviderWebsocket.ts";
-export * from "./types.ts";

package/dist/packages/provider/src/types.d.ts

@@ -1,92 +0,0 @@
-import type { Encoder } from "lib0/encoding";
-import type { Event, MessageEvent } from "ws";
-import type { Awareness } from "y-protocols/awareness";
-import type * as Y from "yjs";
-import type { CloseEvent } from "@hocuspocus/common";
-import type { IncomingMessage } from "./IncomingMessage.ts";
-import type { OutgoingMessage } from "./OutgoingMessage.ts";
-import type { AuthenticationMessage } from "./OutgoingMessages/AuthenticationMessage.ts";
-import type { AwarenessMessage } from "./OutgoingMessages/AwarenessMessage.ts";
-import type { QueryAwarenessMessage } from "./OutgoingMessages/QueryAwarenessMessage.ts";
-import type { SyncStepOneMessage } from "./OutgoingMessages/SyncStepOneMessage.ts";
-import type { SyncStepTwoMessage } from "./OutgoingMessages/SyncStepTwoMessage.ts";
-import type { UpdateMessage } from "./OutgoingMessages/UpdateMessage.ts";
-export declare enum MessageType {
-    Sync = 0,
-    Awareness = 1,
-    Auth = 2,
-    QueryAwareness = 3,
-    Stateless = 5,
-    CLOSE = 7,
-    SyncStatus = 8
-}
-export declare enum WebSocketStatus {
-    Connecting = "connecting",
-    Connected = "connected",
-    Disconnected = "disconnected"
-}
-export interface OutgoingMessageInterface {
-    encoder: Encoder;
-    type?: MessageType;
-}
-export interface OutgoingMessageArguments {
-    documentName: string;
-    token: string;
-    document: Y.Doc;
-    awareness: Awareness;
-    clients: number[];
-    states: Map<number, {
-        [key: string]: any;
-    }>;
-    update: any;
-    payload: string;
-    encoder: Encoder;
-}
-export interface Constructable<T> {
-    new (...args: any): T;
-}
-export type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;
-export type onAuthenticationFailedParameters = {
-    reason: string;
-};
-export type onAuthenticatedParameters = {
-    scope: "read-write" | "readonly";
-};
-export type onOpenParameters = {
-    event: Event;
-};
-export type onMessageParameters = {
-    event: MessageEvent;
-    message: IncomingMessage;
-};
-export type onOutgoingMessageParameters = {
-    message: OutgoingMessage;
-};
-export type onStatusParameters = {
-    status: WebSocketStatus;
-};
-export type onSyncedParameters = {
-    state: boolean;
-};
-export type onUnsyncedChangesParameters = {
-    number: number;
-};
-export type onDisconnectParameters = {
-    event: CloseEvent;
-};
-export type onCloseParameters = {
-    event: CloseEvent;
-};
-export type onAwarenessUpdateParameters = {
-    states: StatesArray;
-};
-export type onAwarenessChangeParameters = {
-    states: StatesArray;
-};
-export type onStatelessParameters = {
-    payload: string;
-};
-export type StatesArray = {
-    clientId: number;
-    [key: string | number]: any;
-}[];

package/dist/packages/server/src/ClientConnection.d.ts

@@ -1,63 +0,0 @@
-import type { IncomingMessage } from "node:http";
-import { type CloseEvent } from "@hocuspocus/common";
-import type WebSocket from "ws";
-import type Document from "./Document.ts";
-import type { Hocuspocus } from "./Hocuspocus.ts";
-import type { onDisconnectPayload } from "./types.ts";
-/**
- * The `ClientConnection` class is responsible for handling an incoming WebSocket
- *
- * TODO-refactor:
- * - use event handlers instead of calling hooks directly, hooks should probably be called from Hocuspocus.ts
- */
-export declare class ClientConnection {
-    private readonly websocket;
-    private readonly request;
-    private readonly documentProvider;
-    private readonly hooks;
-    private readonly opts;
-    private readonly defaultContext;
-    private readonly documentConnections;
-    private readonly incomingMessageQueue;
-    private readonly documentConnectionsEstablished;
-    private readonly hookPayloads;
-    private readonly callbacks;
-    private readonly socketId;
-    timeout: number;
-    pingInterval: NodeJS.Timeout;
-    pongReceived: boolean;
-    /**
-     * The `ClientConnection` class receives incoming WebSocket connections,
-     * runs all hooks:
-     *
-     *  - onConnect for all connections
-     *  - onAuthenticate only if required
-     *
-     * … and if nothings fails it’ll fully establish the connection and
-     * load the Document then.
-     */
-    constructor(websocket: WebSocket, request: IncomingMessage, documentProvider: {
-        createDocument: Hocuspocus["createDocument"];
-    }, hooks: Hocuspocus["hooks"], opts: {
-        timeout: number;
-    }, defaultContext?: any);
-    private handleWebsocketClose;
-    close(event?: CloseEvent): void;
-    handlePong: () => void;
-    /**
-     * Check if pong was received and close the connection otherwise
-     * @private
-     */
-    private check;
-    /**
-     * Set a callback that will be triggered when the connection is closed
-     */
-    onClose(callback: (document: Document, payload: onDisconnectPayload) => void): ClientConnection;
-    /**
-     * Create a new connection by the given request and document
-     */
-    private createConnection;
-    private setUpNewConnection;
-    private handleQueueingMessage;
-    private messageHandler;
-}

package/dist/packages/server/src/Connection.d.ts

@@ -1,71 +0,0 @@
-import type { IncomingMessage as HTTPIncomingMessage } from "node:http";
-import { type CloseEvent } from "@hocuspocus/common";
-import type WebSocket from "ws";
-import type Document from "./Document.ts";
-import type { beforeSyncPayload, onStatelessPayload, onTokenSyncPayload } from "./types.ts";
-export declare class Connection {
-    webSocket: WebSocket;
-    context: any;
-    document: Document;
-    request: HTTPIncomingMessage;
-    callbacks: {
-        onClose: ((document: Document, event?: CloseEvent) => void)[];
-        beforeHandleMessage: (connection: Connection, update: Uint8Array) => Promise<void>;
-        beforeSync: (connection: Connection, payload: Pick<beforeSyncPayload, "type" | "payload">) => Promise<void>;
-        statelessCallback: (payload: onStatelessPayload) => Promise<void>;
-        onTokenSyncCallback: (payload: Partial<onTokenSyncPayload>) => Promise<void>;
-    };
-    socketId: string;
-    readOnly: boolean;
-    /**
-     * Constructor.
-     */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, socketId: string, context: any, readOnly?: boolean);
-    /**
-     * Set a callback that will be triggered when the connection is closed
-     */
-    onClose(callback: (document: Document, event?: CloseEvent) => void): Connection;
-    /**
-     * Set a callback that will be triggered when an stateless message is received
-     */
-    onStatelessCallback(callback: (payload: onStatelessPayload) => Promise<void>): Connection;
-    /**
-     * Set a callback that will be triggered before an message is handled
-     */
-    beforeHandleMessage(callback: (connection: Connection, update: Uint8Array) => Promise<any>): Connection;
-    /**
-     * Set a callback that will be triggered before a sync message is handled
-     */
-    beforeSync(callback: (connection: Connection, payload: Pick<beforeSyncPayload, "type" | "payload">) => Promise<any>): Connection;
-    /**
-     * Set a callback that will be triggered when on token sync message is received
-     */
-    onTokenSyncCallback(callback: (payload: onTokenSyncPayload) => Promise<void>): Connection;
-    /**
-     * Send the given message
-     */
-    send(message: any): void;
-    /**
-     * Send a stateless message with payload
-     */
-    sendStateless(payload: string): void;
-    /**
-     * Request current token from the client
-     */
-    requestToken(): void;
-    /**
-     * Graceful wrapper around the WebSocket close method.
-     */
-    close(event?: CloseEvent): void;
-    /**
-     * Send the current document awareness to the client, if any
-     * @private
-     */
-    private sendCurrentAwareness;
-    /**
-     * Handle an incoming message
-     * @public
-     */
-    handleMessage(data: Uint8Array): void;
-}
-export default Connection;

package/dist/packages/server/src/DirectConnection.d.ts

@@ -1,14 +0,0 @@
-import type Document from "./Document.ts";
-import type { Hocuspocus } from "./Hocuspocus.ts";
-import type { DirectConnection as DirectConnectionInterface } from "./types.ts";
-export declare class DirectConnection implements DirectConnectionInterface {
-    document: Document | null;
-    instance: Hocuspocus;
-    context: any;
-    /**
-     * Constructor.
-     */
-    constructor(document: Document, instance: Hocuspocus, context?: any);
-    transact(transaction: (document: Document) => void): Promise<void>;
-    disconnect(): Promise<void>;
-}