@hocuspocus/extension-throttle 1.0.0-alpha.9 → 1.0.0-beta.2

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

@@ -0,0 +1,163 @@
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import * as mutex from 'lib0/mutex';
+import type { Event, CloseEvent, MessageEvent } from 'ws';
+import EventEmitter from './EventEmitter';
+import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, onSyncedParameters, WebSocketStatus } from './types';
+import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
+export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>> & Partial<CompleteHocuspocusProviderConfiguration>;
+export interface CompleteHocuspocusProviderConfiguration {
+    /**
+     * URL of your @hocuspocus/server instance
+     */
+    url: string;
+    /**
+     * The identifier/name of your document
+     */
+    name: string;
+    /**
+     * The actual Y.js document
+     */
+    document: Y.Doc;
+    /**
+     * Pass `false` to start the connection manually.
+     */
+    connect: boolean;
+    /**
+     * Pass false to disable broadcasting between browser tabs.
+     */
+    broadcast: boolean;
+    /**
+     * An Awareness instance to keep the presence state of all clients.
+     */
+    awareness: Awareness;
+    /**
+     * A token that’s sent to the backend for authentication purposes.
+     */
+    token: string | (() => string) | (() => Promise<string>) | null;
+    /**
+     * URL parameters that should be added.
+     */
+    parameters: {
+        [key: string]: any;
+    };
+    /**
+     * An optional WebSocket polyfill, for example for Node.js
+     */
+    WebSocketPolyfill: any;
+    /**
+     * Force syncing the document in the defined interval.
+     */
+    forceSyncInterval: false | number;
+    /**
+     * 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 intialDelay 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;
+    onAuthenticated: () => void;
+    onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
+    onOpen: (data: onOpenParameters) => void;
+    onConnect: () => void;
+    onMessage: (data: onMessageParameters) => void;
+    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
+    onStatus: (data: onStatusParameters) => void;
+    onSynced: (data: onSyncedParameters) => void;
+    onDisconnect: (data: onDisconnectParameters) => void;
+    onClose: (data: onCloseParameters) => void;
+    onDestroy: () => void;
+    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
+    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
+}
+export declare class HocuspocusProvider extends EventEmitter {
+    configuration: CompleteHocuspocusProviderConfiguration;
+    subscribedToBroadcastChannel: boolean;
+    webSocket: WebSocket | null;
+    shouldConnect: boolean;
+    status: WebSocketStatus;
+    isSynced: boolean;
+    unsyncedChanges: number;
+    isAuthenticated: boolean;
+    lastMessageReceived: number;
+    mux: mutex.mutex;
+    intervals: any;
+    connectionAttempt: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    } | null;
+    constructor(configuration: HocuspocusProviderConfiguration);
+    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
+    boundConnect: () => Promise<unknown>;
+    cancelWebsocketRetry?: () => void;
+    connect(): Promise<unknown>;
+    createWebSocketConnection(): Promise<unknown>;
+    resolveConnectionAttempt(): void;
+    stopConnectionAttempt(): void;
+    rejectConnectionAttempt(): void;
+    get document(): Y.Doc;
+    get awareness(): Awareness;
+    get hasUnsyncedChanges(): boolean;
+    checkConnection(): void;
+    forceSync(): void;
+    boundBeforeUnload: () => void;
+    beforeUnload(): void;
+    registerEventListeners(): void;
+    documentUpdateHandler(update: Uint8Array, origin: any): void;
+    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
+    permissionDeniedHandler(reason: string): void;
+    authenticatedHandler(): void;
+    get serverUrl(): string;
+    get url(): string;
+    get synced(): boolean;
+    set synced(state: boolean);
+    get isAuthenticationRequired(): boolean;
+    disconnect(): void;
+    onOpen(event: Event): Promise<void>;
+    getToken(): Promise<string | null>;
+    startSync(): void;
+    send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
+    onMessage(event: MessageEvent): void;
+    onClose(event: CloseEvent): void;
+    destroy(): void;
+    get broadcastChannel(): string;
+    boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
+    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/IncomingMessage.d.ts

@@ -0,0 +1,14 @@
+import { Decoder } from 'lib0/decoding';
+import { Encoder } from 'lib0/encoding';
+import { MessageType } from './types';
+export declare class IncomingMessage {
+    data: any;
+    encoder: Encoder;
+    decoder: Decoder;
+    constructor(data: any);
+    readVarUint(): MessageType;
+    readVarUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
+}

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

@@ -0,0 +1,13 @@
+import { HocuspocusProvider } from './HocuspocusProvider';
+import { IncomingMessage } from './IncomingMessage';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    broadcasted: boolean;
+    constructor(message: IncomingMessage);
+    setBroadcasted(value: boolean): this;
+    apply(provider: HocuspocusProvider, emitSynced?: boolean): void;
+    private applySyncMessage;
+    private applyAwarenessMessage;
+    private applyAuthMessage;
+    private applyQueryAwarenessMessage;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,3 @@
+export * from './HocuspocusProvider';
+export * from './HocuspocusCloudProvider';
+export * from './types';

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

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

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

@@ -2,9 +2,11 @@
 import AsyncLock from 'async-lock';
 import WebSocket from 'ws';
 import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import { CloseEvent } from '@hocuspocus/common';
 import Document from './Document';
-declare class Connection {
-    connection: WebSocket;
+import { Debugger } from './Debugger';
+export declare class Connection {
+    webSocket: WebSocket;
     context: any;
     document: Document;
     pingInterval: NodeJS.Timeout;
@@ -15,40 +17,58 @@ declare class Connection {
     socketId: string;
     lock: AsyncLock;
     readOnly: Boolean;
+    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly?: boolean);
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
     /**
      * Set a callback that will be triggered when the connection is closed
      */
     onClose(callback: (document: Document) => void): Connection;
+    /**
+     * Set a callback that will be triggered before an message is handled
+     */
+    beforeHandleMessage(callback: (payload: Document, update: Uint8Array) => Promise<any>): Connection;
     /**
      * Send the given message
      */
     send(message: any): void;
     /**
-     * Close the connection
+     * Graceful wrapper around the WebSocket close method.
      */
-    close(): void;
+    close(event?: CloseEvent): void;
     /**
      * Check if pong was received and close the connection otherwise
      * @private
      */
     private check;
     /**
-     * Send first sync step
+     * Send the current document awareness to the client, if any
      * @private
      */
-    private sendFirstSyncStep;
+    private sendCurrentAwareness;
     /**
      * Handle an incoming message
      * @private
      */
     private handleMessage;
+    /**
+     * Handle a ws instance error, which is required to prevent
+     * the server from crashing when one happens
+     * See https://github.com/websockets/ws/issues/1777#issuecomment-660803472
+     * @private
+     */
+    private handleError;
     /**
      * Get the underlying connection instance
+     * @deprecated
      */
     get instance(): WebSocket;
+    /**
+     * Get the underlying connection instance
+     * @deprecated
+     */
+    get connection(): WebSocket;
 }
 export default Connection;

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

@@ -0,0 +1,14 @@
+export declare class Debugger {
+    logs: any[];
+    listen: boolean;
+    output: boolean;
+    enable(): void;
+    disable(): void;
+    verbose(): void;
+    quiet(): void;
+    log(message: any): this;
+    flush(): this;
+    get(): {
+        logs: any[];
+    };
+}

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

@@ -3,18 +3,24 @@ import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
 import { mutex } from 'lib0/mutex.js';
 import Connection from './Connection';
-declare class Document extends Doc {
+import { Debugger } from './Debugger';
+export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {
         onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
     };
-    connections: Map<any, any>;
+    connections: Map<WebSocket, {
+        clients: Set<any>;
+        connection: Connection;
+    }>;
     name: string;
     mux: mutex;
+    logger: Debugger;
+    isLoading: boolean;
     /**
      * Constructor.
      */
-    constructor(name: string);
+    constructor(name: string, logger: Debugger, yDocOptions: {});
     /**
      * Check if the Document is empty
      */
@@ -41,9 +47,9 @@ declare class Document extends Doc {
      */
     removeConnection(connection: Connection): Document;
     /**
-     * Get the number of active connections
+     * Get the number of active connections for this document
      */
-    connectionsCount(): number;
+    getConnectionsCount(): number;
     /**
      * Get an array of registered connections
      */

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

@@ -1,65 +1,111 @@
 /// <reference types="node" />
-import WebSocket from 'ws';
+import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { Configuration } from './types';
+import { Configuration, HookName, HookPayload } from './types';
+import Document from './Document';
+import { Debugger } from './Debugger';
+import { onListenPayload } from '.';
 export declare const defaultConfiguration: {
+    name: null;
     port: number;
     timeout: number;
+    debounce: number;
+    maxDebounce: number;
+    quiet: boolean;
+    yDocOptions: {
+        gc: boolean;
+        gcFilter: () => boolean;
+    };
 };
 /**
- * Hocuspocus yjs websocket server
+ * Hocuspocus Server
  */
 export declare class Hocuspocus {
     configuration: Configuration;
-    documents: Map<any, any>;
+    documents: Map<string, Document>;
     httpServer?: HTTPServer;
-    websocketServer?: WebSocket.Server;
+    webSocketServer?: WebSocketServer;
+    debugger: Debugger;
+    constructor(configuration?: Partial<Configuration>);
     /**
      * Configure the server
      */
     configure(configuration: Partial<Configuration>): Hocuspocus;
+    get requiresAuthentication(): boolean;
     /**
      * Start the server
      */
-    listen(): Promise<void>;
+    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
+     */
+    getDocumentsCount(): number;
+    /**
+     * Get the total number of active connections
+     */
+    getConnectionsCount(): number;
+    /**
+     * Force close one or more connections
+     */
+    closeConnections(documentName?: string): void;
     /**
      * Destroy the server
      */
     destroy(): Promise<any>;
     /**
-     * Handle the incoming websocket connection
+     * The `handleConnection` method 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.
      */
     handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
     /**
      * Handle update of the given document
-     * @private
      */
     private handleDocumentUpdate;
+    timers: Map<string, {
+        timeout: NodeJS.Timeout;
+        start: number;
+    }>;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function, immediately?: boolean): void;
     /**
      * Create a new document by the given request
-     * @private
      */
     private createDocument;
     /**
      * Create a new connection by the given request and document
-     * @private
      */
     private createConnection;
     /**
-     * Run the given hook on all configured extensions
-     * Runs the given callback after each hook
-     * @private
+     * Run the given hook on all configured extensions.
+     * Runs the given callback after each hook.
      */
-    private hooks;
+    hooks(name: HookName, payload: HookPayload, callback?: Function | null): Promise<any>;
     /**
      * Get parameters by the given request
-     * @private
      */
     private static getParameters;
     /**
      * Get document name by the given request
-     * @private
      */
-    private static getDocumentName;
+    private getDocumentNameFromRequest;
+    enableDebugging(): void;
+    enableMessageLogging(): void;
+    disableLogging(): void;
+    disableDebugging(): void;
+    flushMessageLogs(): this;
+    getMessageLogs(): any[];
 }
 export declare const Server: Hocuspocus;

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

@@ -1,15 +1,19 @@
 import { Decoder } from 'lib0/decoding';
 import { Encoder } from 'lib0/encoding';
-import Document from './Document';
-import Connection from './Connection';
+import { MessageType } from './types';
 export declare class IncomingMessage {
+    /**
+     * Access to the received message.
+     */
     decoder: Decoder;
-    syncMessageEncoder?: Encoder;
+    /**
+     * Access to the reply.
+     */
+    encoder: Encoder;
     constructor(input: any);
-    readSyncMessageAndApplyItTo(document: Document, connection?: Connection): void;
-    readUint8Array(): Uint8Array;
+    readVarUint8Array(): Uint8Array;
+    readVarUint(): number;
     toUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
     get length(): number;
-    get messageType(): number;
-    private get encoder();
 }

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

@@ -0,0 +1,13 @@
+import { Awareness } from 'y-protocols/awareness';
+import Connection from './Connection';
+import { IncomingMessage } from './IncomingMessage';
+import { Debugger } from './Debugger';
+import Document from './Document';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    logger: Debugger;
+    constructor(message: IncomingMessage, logger: Debugger);
+    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;
+    applyQueryAwarenessMessage(awareness: Awareness, reply?: (message: Uint8Array) => void): void;
+}

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

@@ -3,9 +3,15 @@ import { Awareness } from 'y-protocols/awareness';
 import Document from './Document';
 export declare class OutgoingMessage {
     encoder: Encoder;
+    type?: number;
+    category?: string;
     constructor();
     createSyncMessage(): OutgoingMessage;
+    createSyncReplyMessage(): OutgoingMessage;
     createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
+    writeQueryAwareness(): OutgoingMessage;
+    writeAuthenticated(): OutgoingMessage;
+    writePermissionDenied(reason: string): OutgoingMessage;
     writeFirstSyncStepFor(document: Document): OutgoingMessage;
     writeUpdate(update: Uint8Array): OutgoingMessage;
     toUint8Array(): Uint8Array;