@hocuspocus/extension-s3 3.2.4

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

@@ -0,0 +1,129 @@
+import type { Extension, Hocuspocus, afterLoadDocumentPayload, afterStoreDocumentPayload, beforeBroadcastStatelessPayload, onAwarenessUpdatePayload, onChangePayload, onConfigurePayload, onDisconnectPayload, onStoreDocumentPayload } from "@hocuspocus/server";
+import { Redlock, type ExecutionResult, type Lock } from '@sesamecare-oss/redlock';
+import type { Cluster, ClusterNode, ClusterOptions, RedisOptions } from "ioredis";
+import RedisClient from "ioredis";
+export type RedisInstance = RedisClient | Cluster;
+export interface Configuration {
+    /**
+     * Redis port
+     */
+    port: number;
+    /**
+     * Redis host
+     */
+    host: string;
+    /**
+     * Redis Cluster
+     */
+    nodes?: ClusterNode[];
+    /**
+     * Duplicate from an existed Redis instance
+     */
+    redis?: RedisInstance;
+    /**
+     * Redis instance creator
+     */
+    createClient?: () => RedisInstance;
+    /**
+     * Options passed directly to Redis constructor
+     *
+     * https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+     */
+    options?: ClusterOptions | RedisOptions;
+    /**
+     * An unique instance name, required to filter messages in Redis.
+     * If none is provided an unique id is generated.
+     */
+    identifier: string;
+    /**
+     * Namespace for Redis keys, if none is provided 'hocuspocus' is used
+     */
+    prefix: string;
+    /**
+     * The maximum time for the Redis lock in ms (in case it can’t be released).
+     */
+    lockTimeout: number;
+    /**
+     * A delay before onDisconnect is executed. This allows last minute updates'
+     * sync messages to be received by the subscription before it's closed.
+     */
+    disconnectDelay: number;
+}
+export declare class Redis implements Extension {
+    /**
+     * Make sure to give that extension a higher priority, so
+     * the `onStoreDocument` hook is able to intercept the chain,
+     * before documents are stored to the database.
+     */
+    priority: number;
+    configuration: Configuration;
+    redisTransactionOrigin: string;
+    pub: RedisInstance;
+    sub: RedisInstance;
+    instance: Hocuspocus;
+    redlock: Redlock;
+    locks: Map<string, {
+        lock: Lock;
+        release?: Promise<ExecutionResult>;
+    }>;
+    messagePrefix: Buffer;
+    /**
+     * When we have a high frequency of updates to a document we don't need tons of setTimeouts
+     * piling up, so we'll track them to keep it to the most recent per document.
+     */
+    private pendingDisconnects;
+    private pendingAfterStoreDocumentResolves;
+    constructor(configuration: Partial<Configuration>);
+    onConfigure({ instance }: onConfigurePayload): Promise<void>;
+    private getKey;
+    private pubKey;
+    private subKey;
+    private lockKey;
+    private encodeMessage;
+    private decodeMessage;
+    /**
+     * Once a document is loaded, subscribe to the channel in Redis.
+     */
+    afterLoadDocument({ documentName, document, }: afterLoadDocumentPayload): Promise<unknown>;
+    /**
+     * Publish the first sync step through Redis.
+     */
+    private publishFirstSyncStep;
+    /**
+     * Let’s ask Redis who is connected already.
+     */
+    private requestAwarenessFromOtherInstances;
+    /**
+     * Before the document is stored, make sure to set a lock in Redis.
+     * That’s meant to avoid conflicts with other instances trying to store the document.
+     */
+    onStoreDocument({ documentName }: onStoreDocumentPayload): Promise<void>;
+    /**
+     * Release the Redis lock, so other instances can store documents.
+     */
+    afterStoreDocument({ documentName, socketId }: afterStoreDocumentPayload): Promise<void>;
+    /**
+     * Handle awareness update messages received directly by this Hocuspocus instance.
+     */
+    onAwarenessUpdate({ documentName, awareness, added, updated, removed, }: onAwarenessUpdatePayload): Promise<number>;
+    /**
+     * Handle incoming messages published on subscribed document channels.
+     * Note that this will also include messages from ourselves as it is not possible
+     * in Redis to filter these.
+     */
+    private handleIncomingMessage;
+    /**
+     * if the ydoc changed, we'll need to inform other Hocuspocus servers about it.
+     */
+    onChange(data: onChangePayload): Promise<any>;
+    /**
+     * Make sure to *not* listen for further changes, when there’s
+     * no one connected anymore.
+     */
+    onDisconnect: ({ documentName }: onDisconnectPayload) => Promise<void>;
+    beforeBroadcastStateless(data: beforeBroadcastStatelessPayload): Promise<number>;
+    /**
+     * Kill the Redlock connection immediately.
+     */
+    onDestroy(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "./Redis.ts";

package/dist/packages/extension-s3/src/S3.d.ts

@@ -0,0 +1,44 @@
+import type { DatabaseConfiguration } from "@hocuspocus/extension-database";
+import { Database } from "@hocuspocus/extension-database";
+import { S3Client } from "@aws-sdk/client-s3";
+export interface S3Configuration extends DatabaseConfiguration {
+    /**
+     * AWS S3 region
+     */
+    region?: string;
+    /**
+     * S3 bucket name
+     */
+    bucket: string;
+    /**
+     * S3 key prefix for documents (optional)
+     */
+    prefix?: string;
+    /**
+     * AWS credentials
+     */
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+    };
+    /**
+     * S3 endpoint URL (for S3-compatible services like MinIO)
+     */
+    endpoint?: string;
+    /**
+     * Force path style URLs (required for MinIO)
+     */
+    forcePathStyle?: boolean;
+    /**
+     * Custom S3 client
+     */
+    s3Client?: S3Client;
+}
+export declare class S3 extends Database {
+    private s3Client?;
+    configuration: S3Configuration;
+    constructor(configuration: Partial<S3Configuration>);
+    private getObjectKey;
+    onConfigure(): Promise<void>;
+    onListen(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "./S3.ts";

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

@@ -0,0 +1,27 @@
+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";
+export declare const upsertQuery = "\n  INSERT INTO \"documents\" (\"name\", \"data\") VALUES ($name, $data)\n    ON CONFLICT(name) DO UPDATE SET data = $data\n";
+export interface SQLiteConfiguration extends DatabaseConfiguration {
+    /**
+     * Valid values are filenames, ":memory:" for an anonymous in-memory database and an empty
+     * string for an anonymous disk-based database. Anonymous databases are not persisted and
+     * when closing the database handle, their contents are lost.
+     *
+     * https://github.com/mapbox/node-sqlite3/wiki/API#new-sqlite3databasefilename-mode-callback
+     */
+    database: string;
+    /**
+     * The database schema to create.
+     */
+    schema: string;
+}
+export declare class SQLite extends Database {
+    db?: sqlite3.Database;
+    configuration: SQLiteConfiguration;
+    constructor(configuration?: Partial<SQLiteConfiguration>);
+    onConfigure(): Promise<void>;
+    onListen(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from "./SQLite.ts";

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

@@ -0,0 +1,30 @@
+import type { Extension, onConnectPayload } from "@hocuspocus/server";
+export interface ThrottleConfiguration {
+    throttle: number | null | false;
+    consideredSeconds: number;
+    banTime: number;
+    cleanupInterval: number;
+}
+export declare class Throttle implements Extension {
+    configuration: ThrottleConfiguration;
+    connectionsByIp: Map<string, Array<number>>;
+    bannedIps: Map<string, number>;
+    cleanupInterval?: NodeJS.Timeout;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<ThrottleConfiguration>);
+    onDestroy(): Promise<void>;
+    clearMaps(): void;
+    isBanned(ip: string): boolean;
+    /**
+     * Throttle requests
+     * @private
+     */
+    private throttle;
+    /**
+     * onConnect hook
+     * @param data
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+}

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

@@ -0,0 +1,56 @@
+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",
+    onCreate = "create",
+    onDisconnect = "disconnect"
+}
+export interface Configuration {
+    debounce: number | false | null;
+    debounceMaxWait: number;
+    secret: string;
+    transformer: Transformer | {
+        toYdoc: (document: any) => Doc;
+        fromYdoc: (document: Doc) => any;
+    };
+    url: string;
+    events: Array<Events>;
+}
+export declare class Webhook implements Extension {
+    configuration: Configuration;
+    debounced: Map<string, {
+        timeout: NodeJS.Timeout;
+        start: number;
+    }>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    /**
+     * Create a signature for the response body
+     */
+    createSignature(body: string): string;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function): void;
+    /**
+     * Send a request to the given url containing the given data
+     */
+    sendRequest(event: Events, payload: any): Promise<import("axios").AxiosResponse<any, any, {}>>;
+    /**
+     * onChange hook
+     */
+    onChange(data: onChangePayload): Promise<void>;
+    /**
+     * onLoadDocument hook
+     */
+    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
+    /**
+     * onConnect hook
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+}

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

@@ -0,0 +1,9 @@
+export default class EventEmitter {
+    callbacks: {
+        [key: string]: Function[];
+    };
+    on(event: string, fn: Function): this;
+    protected emit(event: string, ...args: any): this;
+    off(event: string, fn?: Function): this;
+    removeAllListeners(): void;
+}

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

@@ -0,0 +1,115 @@
+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;
+    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

@@ -0,0 +1,114 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,9 @@
+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;
+}