@hocuspocus/provider 3.0.4-rc.0 → 3.0.7-rc.0

package/dist/packages/common/src/auth.d.ts

@@ -2,5 +2,5 @@ import * as encoding from 'lib0/encoding';
 import * as decoding from 'lib0/decoding';
 export declare const writeAuthentication: (encoder: encoding.Encoder, auth: string) => void;
 export declare const writePermissionDenied: (encoder: encoding.Encoder, reason: string) => void;
-export declare const writeAuthenticated: (encoder: encoding.Encoder, scope: 'readonly' | 'read-write') => void;
+export declare const writeAuthenticated: (encoder: encoding.Encoder, scope: "readonly" | "read-write") => void;
 export declare const readAuthMessage: (decoder: decoding.Decoder, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: (scope: string) => void) => void;

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

@@ -1,4 +1,4 @@
-export * from './auth.js';
-export * from './CloseEvents.js';
-export * from './awarenessStatesToArray.js';
-export * from './types.js';
+export * from './auth.ts';
+export * from './CloseEvents.ts';
+export * from './awarenessStatesToArray.ts';
+export * from './types.ts';

package/dist/packages/extension-database/src/index.d.ts

@@ -1 +1 @@
-export * from './Database.js';
+export * from './Database.ts';

package/dist/packages/extension-logger/src/index.d.ts

@@ -1 +1 @@
-export * from './Logger.js';
+export * from './Logger.ts';

package/dist/packages/extension-redis/src/Redis.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
 import RedisClient from 'ioredis';
 import Redlock from 'redlock';

package/dist/packages/extension-redis/src/index.d.ts

@@ -1 +1 @@
-export * from './Redis.js';
+export * from './Redis.ts';

package/dist/packages/extension-sqlite/src/index.d.ts

@@ -1 +1 @@
-export * from './SQLite.js';
+export * from './SQLite.ts';

package/dist/packages/extension-throttle/src/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { Extension, onConnectPayload } from '@hocuspocus/server';
 export interface ThrottleConfiguration {
     throttle: number | null | false;

package/dist/packages/extension-webhook/src/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
 import type { Doc } from 'yjs';
 import type { Transformer } from '@hocuspocus/transformer';

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

@@ -1,10 +1,10 @@
 import type { Event, MessageEvent } from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
-import EventEmitter from './EventEmitter.js';
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
-import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
-import type { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onSyncedParameters } from './types.js';
+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, 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 {
     /**
@@ -36,7 +36,7 @@ export interface CompleteHocuspocusProviderConfiguration {
      * Force syncing the document in the defined interval.
      */
     forceSyncInterval: false | number;
-    onAuthenticated: () => void;
+    onAuthenticated: (data: onAuthenticatedParameters) => void;
     onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
     onOpen: (data: onOpenParameters) => void;
     onConnect: () => void;
@@ -49,6 +49,7 @@ export interface CompleteHocuspocusProviderConfiguration {
     onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
     onAwarenessChange: (data: onAwarenessChangeParameters) => void;
     onStateless: (data: onStatelessParameters) => void;
+    onUnsyncedChanges: (data: onUnsyncedChangesParameters) => void;
 }
 export declare class AwarenessError extends Error {
     code: number;
@@ -60,7 +61,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     isAuthenticated: boolean;
     authorizedScope: string | undefined;
     manageSocket: boolean;
-    private isAttached;
+    private _isAttached;
     intervals: any;
     constructor(configuration: HocuspocusProviderConfiguration);
     boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
@@ -74,6 +75,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     forwardDestroy: (e: any) => this;
     setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
     get document(): Y.Doc;
+    get isAttached(): boolean;
     get awareness(): Awareness | null;
     get hasUnsyncedChanges(): boolean;
     private resetUnsyncedChanges;
@@ -94,7 +96,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     get synced(): boolean;
     set synced(state: boolean);
     receiveStateless(payload: string): void;
-    connect(): Promise<void>;
+    connect(): Promise<unknown>;
     disconnect(): void;
     onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;

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

@@ -1,8 +1,8 @@
 import type { MessageEvent, Event } from 'ws';
-import EventEmitter from './EventEmitter.js';
-import type { HocuspocusProvider } from './HocuspocusProvider.js';
-import type { onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.js';
-import { WebSocketStatus } from './types.js';
+import EventEmitter from './EventEmitter.ts';
+import type { HocuspocusProvider } from './HocuspocusProvider.ts';
+import type { onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters } from './types.ts';
+import { WebSocketStatus } from './types.ts';
 export type HocusPocusWebSocket = WebSocket & {
     identifier: string;
 };
@@ -95,9 +95,7 @@ export declare class HocuspocusProviderWebsocket extends EventEmitter {
     } | null;
     constructor(configuration: HocuspocusProviderWebsocketConfiguration);
     receivedOnOpenPayload?: Event | undefined;
-    receivedOnStatusPayload?: onStatusParameters | undefined;
     onOpen(event: Event): Promise<void>;
-    onStatus(data: onStatusParameters): Promise<void>;
     attach(provider: HocuspocusProvider): void;
     detach(provider: HocuspocusProvider): void;
     setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;

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

@@ -1,6 +1,6 @@
 import type { Decoder } from 'lib0/decoding';
 import type { Encoder } from 'lib0/encoding';
-import type { MessageType } from './types.js';
+import type { MessageType } from './types.ts';
 export declare class IncomingMessage {
     data: any;
     encoder: Encoder;
@@ -9,7 +9,7 @@ export declare class IncomingMessage {
     peekVarString(): string;
     readVarUint(): MessageType;
     readVarString(): string;
-    readVarUint8Array(): Uint8Array;
+    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
     writeVarUint(type: MessageType): void;
     writeVarString(string: string): void;
     writeVarUint8Array(data: Uint8Array): void;

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

@@ -1,5 +1,5 @@
-import type { HocuspocusProvider } from './HocuspocusProvider.js';
-import type { IncomingMessage } from './IncomingMessage.js';
+import type { HocuspocusProvider } from './HocuspocusProvider.ts';
+import type { IncomingMessage } from './IncomingMessage.ts';
 export declare class MessageReceiver {
     message: IncomingMessage;
     constructor(message: IncomingMessage);

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

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

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

@@ -1,9 +1,9 @@
 import type { Encoder } from 'lib0/encoding';
-import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js';
+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;
+    toUint8Array(): Uint8Array<ArrayBufferLike>;
 }

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

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,7 +1,7 @@
 import * as encoding from 'lib0/encoding';
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

@@ -1,6 +1,6 @@
-import type { OutgoingMessageArguments } from '../types.js';
-import { MessageType } from '../types.js';
-import { OutgoingMessage } from '../OutgoingMessage.js';
+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;

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

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

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

@@ -3,14 +3,14 @@ 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.js';
-import type { OutgoingMessage } from './OutgoingMessage.js';
-import type { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
-import type { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
-import type { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
-import type { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
-import type { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
-import type { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
+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,
@@ -49,6 +49,9 @@ export type ConstructableOutgoingMessage = Constructable<AuthenticationMessage>
 export type onAuthenticationFailedParameters = {
     reason: string;
 };
+export type onAuthenticatedParameters = {
+    scope: 'read-write' | 'readonly';
+};
 export type onOpenParameters = {
     event: Event;
 };
@@ -65,6 +68,9 @@ export type onStatusParameters = {
 export type onSyncedParameters = {
     state: boolean;
 };
+export type onUnsyncedChangesParameters = {
+    number: number;
+};
 export type onDisconnectParameters = {
     event: CloseEvent;
 };
@@ -84,103 +90,3 @@ export type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
-export type TCollabThread<Data = any, CommentData = any> = {
-    id: string;
-    createdAt: number;
-    updatedAt: number;
-    deletedAt: number | null;
-    resolvedAt?: string;
-    comments: TCollabComment<CommentData>[];
-    deletedComments: TCollabComment<CommentData>[];
-    data: Data;
-};
-export type TCollabComment<Data = any> = {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    deletedAt?: string;
-    data: Data;
-    content: any;
-};
-export type THistoryVersion = {
-    name?: string;
-    version: number;
-    date: number;
-};
-export type THistoryConfiguration = {
-    autoVersioning: boolean;
-    currentVersion: number;
-    stateCaptured: number;
-};
-export type THistoryAction = THistoryDocumentRevertAction | THistoryVersionCreateAction | THistoryVersionPreviewAction;
-export type THistoryDocumentRevertAction = {
-    action: 'document.revert';
-    /**
-     * if changes haven't been persisted to a version yet, we'll create one with the specified name,
-     * expect when `false` is passed.
-     */
-    currentVersionName?: string | false;
-    /**
-     * Name of the version that is created after the revert. Pass `false` to avoid generating a new version.
-     */
-    newVersionName?: string | false;
-};
-export type THistoryVersionCreateAction = {
-    action: 'version.create';
-    name?: string;
-};
-export type THistoryVersionPreviewAction = {
-    action: 'version.preview';
-    version: number;
-};
-export type THistoryEvent = THistoryVersionPreviewEvent | THistoryVersionCreatedEvent | THistoryDocumentRevertedEvent;
-export type THistoryVersionCreatedEvent = {
-    event: 'version.created';
-    version: number;
-};
-export type THistoryVersionPreviewEvent = {
-    event: 'version.preview';
-    version: number;
-    ydoc: string;
-};
-export type THistoryDocumentRevertedEvent = {
-    event: 'document.reverted';
-    version: number;
-};
-export type DeleteCommentOptions = {
-    /**
-     * If `true`, the thread will also be deleted if the deleted comment was the first comment in the thread.
-     */
-    deleteThread?: boolean;
-    /**
-     * If `true`, will remove the content of the deleted comment
-     */
-    deleteContent?: boolean;
-};
-export type DeleteThreadOptions = {
-    /**
-     * If `true`, will remove the comments on the thread,
-     * otherwise will only mark the thread as deleted
-     * and keep the comments
-     * @default false
-     */
-    deleteComments?: boolean;
-    /**
-     * If `true`, will forcefully remove the thread and all comments,
-     * otherwise will only mark the thread as deleted
-     * and keep the comments
-     * @default false
-     */
-    force?: boolean;
-};
-/**
- * The type of thread
- */
-export type ThreadType = 'archived' | 'unarchived';
-export type GetThreadsOptions = {
-    /**
-     * The types of threads to get
-     * @default ['unarchived']
-     */
-    types?: Array<ThreadType>;
-};

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

@@ -1,11 +1,9 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import { type CloseEvent } from '@hocuspocus/common';
 import type WebSocket from 'ws';
-import type Document from './Document.js';
-import type { Hocuspocus } from './Hocuspocus.js';
-import type { onDisconnectPayload } from './types.js';
+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
  *

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

@@ -1,15 +1,19 @@
-/// <reference types="node" />
 import type { IncomingMessage as HTTPIncomingMessage } from 'http';
-import type WebSocket from 'ws';
 import { type CloseEvent } from '@hocuspocus/common';
-import type Document from './Document.js';
-import type { onStatelessPayload } from './types.js';
+import type WebSocket from 'ws';
+import type Document from './Document.ts';
+import type { beforeSyncPayload, onStatelessPayload } from './types.ts';
 export declare class Connection {
     webSocket: WebSocket;
     context: any;
     document: Document;
     request: HTTPIncomingMessage;
-    callbacks: any;
+    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>;
+    };
     socketId: string;
     readOnly: boolean;
     /**
@@ -28,6 +32,10 @@ export declare class 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;
     /**
      * Send the given message
      */

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

@@ -1,6 +1,6 @@
-import type Document from './Document.js';
-import type { Hocuspocus } from './Hocuspocus.js';
-import type { DirectConnection as DirectConnectionInterface } from './types.js';
+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;

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

@@ -1,7 +1,7 @@
 import type WebSocket from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
-import type Connection from './Connection.js';
+import type Connection from './Connection.ts';
 export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {

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

@@ -1,10 +1,9 @@
-/// <reference types="node" />
 import type { IncomingMessage } from 'http';
 import type WebSocket from 'ws';
-import type { Server } from './Server.js';
-import { DirectConnection } from './DirectConnection.js';
-import Document from './Document.js';
-import type { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onStoreDocumentPayload } from './types.js';
+import { DirectConnection } from './DirectConnection.ts';
+import Document from './Document.ts';
+import type { Server } from './Server.ts';
+import type { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onStoreDocumentPayload } from './types.ts';
 export declare const defaultConfiguration: {
     name: null;
     timeout: number;

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

@@ -1,6 +1,6 @@
 import type { Decoder } from 'lib0/decoding';
 import type { Encoder } from 'lib0/encoding';
-import type { MessageType } from './types.js';
+import type { MessageType } from './types.ts';
 export declare class IncomingMessage {
     /**
      * Access to the received message.
@@ -14,10 +14,11 @@ export declare class IncomingMessage {
     private encoderInternal?;
     constructor(input: any);
     get encoder(): Encoder;
-    readVarUint8Array(): Uint8Array;
+    readVarUint8Array(): Uint8Array<ArrayBufferLike>;
+    peekVarUint8Array(): Uint8Array<ArrayBufferLike>;
     readVarUint(): number;
     readVarString(): string;
-    toUint8Array(): Uint8Array;
+    toUint8Array(): Uint8Array<ArrayBufferLike>;
     writeVarUint(type: MessageType): void;
     writeVarString(string: string): void;
     get length(): number;

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

@@ -1,11 +1,11 @@
-import type Connection from './Connection.js';
-import type Document from './Document.js';
-import type { IncomingMessage } from './IncomingMessage.js';
+import type Connection from './Connection.ts';
+import type Document from './Document.ts';
+import type { IncomingMessage } from './IncomingMessage.ts';
 export declare class MessageReceiver {
     message: IncomingMessage;
     defaultTransactionOrigin?: string;
     constructor(message: IncomingMessage, defaultTransactionOrigin?: string);
-    apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): void;
-    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): 0 | 1 | 2;
+    apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): Promise<void>;
+    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): Promise<0 | 1 | 2>;
     applyQueryAwarenessMessage(document: Document, reply?: (message: Uint8Array) => void): void;
 }

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

@@ -1,6 +1,6 @@
 import type { Encoder } from 'lib0/encoding';
 import type { Awareness } from 'y-protocols/awareness';
-import type Document from './Document.js';
+import type Document from './Document.ts';
 export declare class OutgoingMessage {
     encoder: Encoder;
     type?: number;

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

@@ -1,8 +1,7 @@
-/// <reference types="node" />
 import type { IncomingMessage, Server as HTTPServer, ServerResponse } from 'http';
 import { WebSocketServer } from 'ws';
 import type { AddressInfo, ServerOptions } from 'ws';
-import { Hocuspocus } from './Hocuspocus.js';
+import { Hocuspocus } from './Hocuspocus.ts';
 import type { Configuration } from './types';
 export interface ServerConfiguration extends Configuration {
     port?: number;

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

@@ -1,9 +1,9 @@
-export * from './Connection.js';
-export * from './Document.js';
-export * from './Hocuspocus.js';
-export * from './IncomingMessage.js';
-export * from './MessageReceiver.js';
-export * from './OutgoingMessage.js';
-export * from './Server.js';
-export * from './types.js';
-export * from './util/debounce.js';
+export * from './Connection.ts';
+export * from './Document.ts';
+export * from './Hocuspocus.ts';
+export * from './IncomingMessage.ts';
+export * from './MessageReceiver.ts';
+export * from './OutgoingMessage.ts';
+export * from './Server.ts';
+export * from './types.ts';
+export * from './util/debounce.ts';