@hocuspocus/extension-webhook 2.13.5-rc.0 → 3.0.0-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/extension-database/src/Database.d.ts

@@ -1,4 +1,4 @@
-import { Extension, onChangePayload, onLoadDocumentPayload, storePayload, fetchPayload } from '@hocuspocus/server';
+import type { Extension, onChangePayload, onLoadDocumentPayload, storePayload, fetchPayload } from '@hocuspocus/server';
 export interface DatabaseConfiguration {
     /**
      * Pass a Promise to retrieve updates from your database. The Promise should resolve to

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

@@ -1,4 +1,4 @@
-import { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDestroyPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from '@hocuspocus/server';
+import type { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDestroyPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from '@hocuspocus/server';
 export interface LoggerConfiguration {
     /**
      * Prepend all logging message with a string.

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

@@ -1,7 +1,8 @@
-/// <reference types="node" />
-import RedisClient, { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
+import type { ClusterNode, ClusterOptions, RedisOptions } from 'ioredis';
+import RedisClient from 'ioredis';
 import Redlock from 'redlock';
-import { Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, Debugger, onConfigurePayload, beforeBroadcastStatelessPayload, Hocuspocus } from '@hocuspocus/server';
+import type { Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, onConfigurePayload, beforeBroadcastStatelessPayload, Hocuspocus } from '@hocuspocus/server';
+import { Debugger } from '@hocuspocus/server';
 export type RedisInstance = RedisClient.Cluster | RedisClient.Redis;
 export interface Configuration {
     /**

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

@@ -1,4 +1,5 @@
-import { Database, DatabaseConfiguration } from '@hocuspocus/extension-database';
+import type { DatabaseConfiguration } from '@hocuspocus/extension-database';
+import { Database } from '@hocuspocus/extension-database';
 import sqlite3 from 'sqlite3';
 export declare const schema = "CREATE TABLE IF NOT EXISTS \"documents\" (\n  \"name\" varchar(255) NOT NULL,\n  \"data\" blob NOT NULL,\n  UNIQUE(name)\n)";
 export declare const selectQuery = "\n  SELECT data FROM \"documents\" WHERE name = $name ORDER BY rowid DESC\n";

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

@@ -1,5 +1,4 @@
-/// <reference types="node" />
-import { Extension, onConnectPayload } from '@hocuspocus/server';
+import type { Extension, onConnectPayload } from '@hocuspocus/server';
 export interface ThrottleConfiguration {
     throttle: number | null | false;
     consideredSeconds: number;
@@ -10,7 +9,7 @@ export declare class Throttle implements Extension {
     configuration: ThrottleConfiguration;
     connectionsByIp: Map<string, Array<number>>;
     bannedIps: Map<string, number>;
-    cleanupInterval?: NodeJS.Timer;
+    cleanupInterval?: NodeJS.Timeout;
     /**
      * Constructor
      */

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

@@ -1,7 +1,6 @@
-/// <reference types="node" />
-import { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
-import { Doc } from 'yjs';
-import { Transformer } from '@hocuspocus/transformer';
+import type { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
+import type { Doc } from 'yjs';
+import type { Transformer } from '@hocuspocus/transformer';
 export declare enum Events {
     onChange = "change",
     onConnect = "connect",

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

@@ -3,8 +3,9 @@ import type { CloseEvent, Event, MessageEvent } from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import * as Y from 'yjs';
 import EventEmitter from './EventEmitter.js';
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
-import { ConstructableOutgoingMessage, WebSocketStatus, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters } from './types.js';
+import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
+import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+import type { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters } from './types.js';
 export type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'name'>> & Partial<CompleteHocuspocusProviderConfiguration> & (Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> | Required<Pick<CompleteHocuspocusProviderConfiguration, 'websocketProvider'>>);
 export interface CompleteHocuspocusProviderConfiguration {
     /**
@@ -81,24 +82,19 @@ export declare class HocuspocusProvider extends EventEmitter {
     subscribedToBroadcastChannel: boolean;
     isSynced: boolean;
     unsyncedChanges: number;
-    status: WebSocketStatus;
     isAuthenticated: boolean;
     authorizedScope: string | undefined;
     mux: mutex.mutex;
     intervals: any;
-    isConnected: boolean;
     constructor(configuration: HocuspocusProviderConfiguration);
-    boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
     boundPageHide: () => void;
     boundOnOpen: (event: Event) => Promise<void>;
     boundOnClose: (event: CloseEvent) => void;
-    boundOnStatus: ({ status }: onStatusParameters) => void;
     forwardConnect: (e: any) => this;
     forwardOpen: (e: any) => this;
     forwardClose: (e: any) => this;
     forwardDisconnect: (e: any) => this;
     forwardDestroy: (e: any) => this;
-    onStatus({ status }: onStatusParameters): void;
     setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
     get document(): Y.Doc;
     get awareness(): Awareness | null;
@@ -122,7 +118,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     set synced(state: boolean);
     receiveStateless(payload: string): void;
     get isAuthenticationRequired(): boolean;
-    connect(): Promise<any>;
+    connect(): Promise<void>;
     disconnect(): void;
     onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;
@@ -133,10 +129,5 @@ export declare class HocuspocusProvider extends EventEmitter {
     destroy(): void;
     permissionDeniedHandler(reason: string): void;
     authenticatedHandler(scope: string): void;
-    get broadcastChannel(): string;
-    broadcastChannelSubscriber(data: ArrayBuffer): void;
-    subscribeToBroadcastChannel(): void;
-    disconnectBroadcastChannel(): void;
-    broadcast(Message: ConstructableOutgoingMessage, args?: any): void;
     setAwarenessField(key: string, value: any): void;
 }

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

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

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

@@ -1,6 +1,6 @@
-import { Decoder } from 'lib0/decoding';
-import { Encoder } from 'lib0/encoding';
-import { MessageType } from './types.js';
+import type { Decoder } from 'lib0/decoding';
+import type { Encoder } from 'lib0/encoding';
+import type { MessageType } from './types.js';
 export declare class IncomingMessage {
     data: any;
     encoder: Encoder;

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

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

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

@@ -1,5 +1,5 @@
-import { Encoder } from 'lib0/encoding';
-import { ConstructableOutgoingMessage } from './types.js';
+import type { Encoder } from 'lib0/encoding';
+import type { ConstructableOutgoingMessage } from './types.js';
 export declare class MessageSender {
     encoder: Encoder;
     message: any;

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

@@ -1,5 +1,5 @@
-import { Encoder } from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js';
+import type { Encoder } from 'lib0/encoding';
+import type { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types.js';
 export declare class OutgoingMessage implements OutgoingMessageInterface {
     encoder: Encoder;
     type?: MessageType;

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

@@ -1,4 +1,5 @@
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class AuthenticationMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class AwarenessMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class CloseMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class QueryAwarenessMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,4 +1,5 @@
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class StatelessMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class SyncStepOneMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,5 +1,6 @@
 import * as encoding from 'lib0/encoding';
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class SyncStepTwoMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,4 +1,5 @@
-import { MessageType, OutgoingMessageArguments } from '../types.js';
+import type { OutgoingMessageArguments } from '../types.js';
+import { MessageType } from '../types.js';
 import { OutgoingMessage } from '../OutgoingMessage.js';
 export declare class UpdateMessage extends OutgoingMessage {
     type: MessageType;

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

@@ -1,6 +1,7 @@
 import type { AbstractType, YArrayEvent } from 'yjs';
 import * as Y from 'yjs';
-import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
+import type { HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
+import { HocuspocusProvider } from './HocuspocusProvider.js';
 import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
 import type { TCollabComment, TCollabThread, THistoryVersion } from './types.js';
 export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'baseUrl'>>) & Pick<AdditionalTiptapCollabProviderConfiguration, 'user'>;

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

@@ -1,4 +1,5 @@
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
+import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
 export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
 export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
     /**

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

@@ -1,16 +1,16 @@
-import { Encoder } from 'lib0/encoding';
+import type { Encoder } from 'lib0/encoding';
 import type { Event, MessageEvent } from 'ws';
-import { Awareness } from 'y-protocols/awareness';
-import * as Y from 'yjs';
-import { CloseEvent } from '@hocuspocus/common';
-import { IncomingMessage } from './IncomingMessage.js';
-import { OutgoingMessage } from './OutgoingMessage.js';
-import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage.js';
-import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage.js';
-import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage.js';
-import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage.js';
-import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage.js';
-import { UpdateMessage } from './OutgoingMessages/UpdateMessage.js';
+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';
 export declare enum MessageType {
     Sync = 0,
     Awareness = 1,

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

@@ -1,10 +1,9 @@
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import WebSocket from 'ws';
-import { Debugger } from './Debugger.js';
-import Document from './Document.js';
-import { Hocuspocus } from './Hocuspocus.js';
-import { onDisconnectPayload } from './types.js';
+import type { IncomingMessage } from 'http';
+import type WebSocket from 'ws';
+import type { Debugger } from './Debugger.js';
+import type Document from './Document.js';
+import type { Hocuspocus } from './Hocuspocus.js';
+import type { onDisconnectPayload } from './types.js';
 /**
  * The `ClientConnection` class is responsible for handling an incoming WebSocket
  *

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

@@ -1,12 +1,10 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import type { IncomingMessage as HTTPIncomingMessage } from 'http';
 import AsyncLock from 'async-lock';
-import WebSocket from 'ws';
-import { CloseEvent } from '@hocuspocus/common';
-import Document from './Document.js';
-import { Debugger } from './Debugger.js';
-import { onStatelessPayload } from './types.js';
+import type WebSocket from 'ws';
+import type { CloseEvent } from '@hocuspocus/common';
+import type Document from './Document.js';
+import type { Debugger } from './Debugger.js';
+import type { onStatelessPayload } from './types.js';
 export declare class Connection {
     webSocket: WebSocket;
     context: any;
@@ -18,7 +16,7 @@ export declare class Connection {
     callbacks: any;
     socketId: string;
     lock: AsyncLock;
-    readOnly: Boolean;
+    readOnly: boolean;
     logger: Debugger;
     /**
      * Constructor.

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

@@ -1,4 +1,4 @@
-import Document from './Document.js';
+import type Document from './Document.js';
 import type { Hocuspocus } from './Hocuspocus.js';
 import type { DirectConnection as DirectConnectionInterface } from './types.js';
 export declare class DirectConnection implements DirectConnectionInterface {

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

@@ -1,9 +1,9 @@
-import WebSocket from 'ws';
+import type WebSocket from 'ws';
 import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
-import { mutex } from 'lib0/mutex.js';
-import Connection from './Connection.js';
-import { Debugger } from './Debugger.js';
+import type { mutex } from 'lib0/mutex.js';
+import type Connection from './Connection.js';
+import type { Debugger } from './Debugger.js';
 export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {
@@ -23,7 +23,7 @@ export declare class Document extends Doc {
     /**
      * Constructor.
      */
-    constructor(name: string, logger?: Debugger, yDocOptions?: {});
+    constructor(name: string, logger?: Debugger, yDocOptions?: object);
     /**
      * Check if the Document (XMLFragment or Map) is empty
      */

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

@@ -1,15 +1,12 @@
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import WebSocket, { AddressInfo } from 'ws';
-import { Server as HocuspocusServer } from './Server.js';
+import type { IncomingMessage } from 'http';
+import type WebSocket from 'ws';
+import type { Server } from './Server.js';
 import { Debugger } from './Debugger.js';
 import { DirectConnection } from './DirectConnection.js';
 import Document from './Document.js';
-import { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onListenPayload, onStoreDocumentPayload } from './types.js';
+import type { Configuration, ConnectionConfiguration, HookName, HookPayloadByName, onStoreDocumentPayload } from './types.js';
 export declare const defaultConfiguration: {
     name: null;
-    port: number;
-    address: string;
     timeout: number;
     debounce: number;
     maxDebounce: number;
@@ -19,16 +16,12 @@ export declare const defaultConfiguration: {
         gcFilter: () => boolean;
     };
     unloadImmediately: boolean;
-    stopOnSignals: boolean;
 };
-/**
- * Hocuspocus Server
- */
 export declare class Hocuspocus {
     configuration: Configuration;
     loadingDocuments: Map<string, Promise<Document>>;
     documents: Map<string, Document>;
-    server?: HocuspocusServer;
+    server?: Server;
     debugger: Debugger;
     debouncer: {
         debounce: (id: string, func: Function, debounce: number, maxDebounce: number) => any;
@@ -37,19 +30,10 @@ export declare class Hocuspocus {
     };
     constructor(configuration?: Partial<Configuration>);
     /**
-     * Configure the server
+     * Configure Hocuspocus
      */
     configure(configuration: Partial<Configuration>): Hocuspocus;
     get requiresAuthentication(): boolean;
-    /**
-     * Start the server
-     */
-    listen(portOrCallback?: number | ((data: onListenPayload) => Promise<any>) | null, callback?: any): Promise<Hocuspocus>;
-    get address(): AddressInfo;
-    get URL(): string;
-    get webSocketURL(): string;
-    get httpURL(): string;
-    private showStartScreen;
     /**
      * Get the total number of active documents
      */
@@ -62,10 +46,6 @@ export declare class Hocuspocus {
      * Force close one or more connections
      */
     closeConnections(documentName?: string): void;
-    /**
-     * Destroy the server
-     */
-    destroy(): Promise<any>;
     /**
      * The `handleConnection` method receives incoming WebSocket connections,
      * runs all hooks:
@@ -104,4 +84,3 @@ export declare class Hocuspocus {
     getMessageLogs(): any[];
     openDirectConnection(documentName: string, context?: any): Promise<DirectConnection>;
 }
-export declare const Server: Hocuspocus;

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

@@ -1,6 +1,6 @@
-import { Decoder } from 'lib0/decoding';
-import { Encoder } from 'lib0/encoding';
-import { MessageType } from './types.js';
+import type { Decoder } from 'lib0/decoding';
+import type { Encoder } from 'lib0/encoding';
+import type { MessageType } from './types.js';
 export declare class IncomingMessage {
     /**
      * Access to the received message.

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

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

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

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

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

@@ -1,13 +1,32 @@
-/// <reference types="node" />
-import { IncomingMessage, Server as HTTPServer, ServerResponse } from 'http';
+import type { IncomingMessage, Server as HTTPServer, ServerResponse } from 'http';
+import type { AddressInfo } from 'ws';
 import { WebSocketServer } from 'ws';
 import { Hocuspocus } from './Hocuspocus.js';
+import type { Configuration } from './types';
+export interface ServerConfiguration extends Configuration {
+    port?: number;
+    address?: string;
+    stopOnSignals?: boolean;
+}
+export declare const defaultServerConfiguration: {
+    port: number;
+    address: string;
+    stopOnSignals: boolean;
+};
 export declare class Server {
     httpServer: HTTPServer;
     webSocketServer: WebSocketServer;
     hocuspocus: Hocuspocus;
-    constructor(hocuspocus: Hocuspocus);
+    configuration: ServerConfiguration;
+    constructor(configuration?: Partial<ServerConfiguration>);
     setupWebsocketConnection: () => void;
     setupHttpUpgrade: () => void;
     requestHandler: (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+    listen(port?: number, callback?: any): Promise<Hocuspocus>;
+    get address(): AddressInfo;
+    destroy(): Promise<any>;
+    get URL(): string;
+    get webSocketURL(): string;
+    get httpURL(): string;
+    private showStartScreen;
 }

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

@@ -5,5 +5,6 @@ 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';

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

@@ -1,19 +1,16 @@
-/// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
-import { URLSearchParams } from 'url';
-import { Awareness } from 'y-protocols/awareness';
-import Connection from './Connection.js';
-import Document from './Document.js';
-import { Hocuspocus } from './Hocuspocus.js';
+import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
+import type { URLSearchParams } from 'url';
+import type { Awareness } from 'y-protocols/awareness';
+import type Connection from './Connection.js';
+import type Document from './Document.js';
+import type { Hocuspocus } from './Hocuspocus.js';
 export declare enum MessageType {
     Unknown = -1,
     Sync = 0,
     Awareness = 1,
     Auth = 2,
     QueryAwareness = 3,
-    SyncReply = 4,
+    SyncReply = 4,// same as Sync, but won't trigger another 'SyncStep1'
     Stateless = 5,
     BroadcastStateless = 6,
     CLOSE = 7,
@@ -85,14 +82,6 @@ export interface Configuration extends Extension {
      * A list of hocuspocus extensions.
      */
     extensions: Array<Extension>;
-    /**
-     * The port which the server listens on.
-     */
-    port?: number;
-    /**
-     * The address which the server listens on.
-     */
-    address?: string;
     /**
      * Defines in which interval the server sends a ping, and closes the connection when no pong is sent back.
      */
@@ -118,12 +107,6 @@ export interface Configuration extends Extension {
      * your onStoreDocument is rate-limited.
      */
     unloadImmediately: boolean;
-    /**
-     * the server will gracefully stop if SIGINT, SIGQUIT or SIGTERM is received.
-     *
-     * Set this to false if you don't want that.
-     */
-    stopOnSignals: boolean;
     /**
      * options to pass to the ydoc document
      */

package/dist/packages/server/src/util/getParameters.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
+import type { IncomingMessage } from 'http';
 import { URLSearchParams } from 'url';
 /**
    * Get parameters by the given request

package/dist/packages/transformer/src/Prosemirror.d.ts

@@ -1,6 +1,6 @@
 import { Doc } from 'yjs';
 import { Schema } from '@tiptap/pm/model';
-import { Transformer } from './types.js';
+import type { Transformer } from './types.js';
 declare class Prosemirror implements Transformer {
     defaultSchema: Schema;
     schema(schema: Schema): Prosemirror;