@hocuspocus/extension-sqlite 2.0.6 → 2.1.0

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

@@ -1,110 +1,110 @@
-import * as Y from 'yjs';
-import { Awareness } from 'y-protocols/awareness';
-import * as mutex from 'lib0/mutex';
-import type { CloseEvent, Event, MessageEvent } from 'ws';
-import EventEmitter from './EventEmitter';
-import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, WebSocketStatus } from './types';
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket';
-import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
-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;
-    /**
-     * 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;
-    };
-    /**
-     * Hocuspocus websocket provider
-     */
-    websocketProvider: HocuspocusProviderWebsocket;
-    /**
-     * Force syncing the document in the defined interval.
-     */
-    forceSyncInterval: false | 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;
-    onStateless: (data: onStatelessParameters) => void;
-    /**
-     * Don’t output any warnings.
-     */
-    quiet: boolean;
-}
-export declare class HocuspocusProvider extends EventEmitter {
-    configuration: CompleteHocuspocusProviderConfiguration;
-    subscribedToBroadcastChannel: boolean;
-    isSynced: boolean;
-    unsyncedChanges: number;
-    status: WebSocketStatus;
-    isAuthenticated: boolean;
-    mux: mutex.mutex;
-    intervals: any;
-    isConnected: boolean;
-    constructor(configuration: HocuspocusProviderConfiguration);
-    onStatus({ status }: onStatusParameters): void;
-    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
-    get document(): Y.Doc;
-    get awareness(): Awareness;
-    get hasUnsyncedChanges(): boolean;
-    updateUnsyncedChanges(unsyncedChanges?: number): void;
-    forceSync(): void;
-    boundBeforeUnload: () => void;
-    beforeUnload(): void;
-    registerEventListeners(): void;
-    sendStateless(payload: string): void;
-    documentUpdateHandler(update: Uint8Array, origin: any): void;
-    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
-    get synced(): boolean;
-    set synced(state: boolean);
-    receiveStateless(payload: string): void;
-    get isAuthenticationRequired(): boolean;
-    connect(): Promise<unknown>;
-    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;
-    permissionDeniedHandler(reason: string): void;
-    authenticatedHandler(): 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;
-}
+import * as Y from 'yjs';
+import { Awareness } from 'y-protocols/awareness';
+import * as mutex from 'lib0/mutex';
+import type { CloseEvent, Event, MessageEvent } from 'ws';
+import EventEmitter from './EventEmitter.js';
+import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters } from './types.js';
+import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+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;
+    /**
+     * 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;
+    };
+    /**
+     * Hocuspocus websocket provider
+     */
+    websocketProvider: HocuspocusProviderWebsocket;
+    /**
+     * Force syncing the document in the defined interval.
+     */
+    forceSyncInterval: false | 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;
+    onStateless: (data: onStatelessParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
+}
+export declare class HocuspocusProvider extends EventEmitter {
+    configuration: CompleteHocuspocusProviderConfiguration;
+    subscribedToBroadcastChannel: boolean;
+    isSynced: boolean;
+    unsyncedChanges: number;
+    status: WebSocketStatus;
+    isAuthenticated: boolean;
+    authorizedScope: string | undefined;
+    mux: mutex.mutex;
+    intervals: any;
+    isConnected: boolean;
+    constructor(configuration: HocuspocusProviderConfiguration);
+    onStatus({ status }: onStatusParameters): void;
+    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
+    get document(): Y.Doc;
+    get awareness(): Awareness;
+    get hasUnsyncedChanges(): boolean;
+    updateUnsyncedChanges(unsyncedChanges?: number): void;
+    forceSync(): void;
+    boundBeforeUnload: () => void;
+    beforeUnload(): void;
+    registerEventListeners(): void;
+    sendStateless(payload: string): void;
+    documentUpdateHandler(update: Uint8Array, origin: any): void;
+    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
+    get synced(): boolean;
+    set synced(state: boolean);
+    receiveStateless(payload: string): void;
+    get isAuthenticationRequired(): boolean;
+    connect(): Promise<unknown>;
+    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;
+    permissionDeniedHandler(reason: string): void;
+    authenticatedHandler(scope: string): 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/HocuspocusProviderWebsocket.d.ts

@@ -1,115 +1,115 @@
-import * as mutex from 'lib0/mutex';
-import type { MessageEvent } from 'ws';
-import { Event } from 'ws';
-import EventEmitter from './EventEmitter';
-import { onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, WebSocketStatus } from './types';
-import { HocuspocusProvider, onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
-export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
-export interface CompleteHocuspocusProviderWebsocketConfiguration {
-    /**
-     * URL of your @hocuspocus/server instance
-     */
-    url: string;
-    /**
-     * Pass `false` to start the connection manually.
-     */
-    connect: boolean;
-    /**
-     * URL parameters that should be added.
-     */
-    parameters: {
-        [key: string]: any;
-    };
-    /**
-     * 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 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;
-    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;
-    /**
-     * Don’t output any warnings.
-     */
-    quiet: boolean;
-}
-export declare class HocuspocusProviderWebsocket extends EventEmitter {
-    configuration: CompleteHocuspocusProviderWebsocketConfiguration;
-    subscribedToBroadcastChannel: boolean;
-    webSocket: WebSocket | null;
-    shouldConnect: boolean;
-    status: WebSocketStatus;
-    lastMessageReceived: number;
-    mux: mutex.mutex;
-    intervals: any;
-    connectionAttempt: {
-        resolve: (value?: any) => void;
-        reject: (reason?: any) => void;
-    } | 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;
-    boundConnect: () => Promise<unknown>;
-    cancelWebsocketRetry?: () => void;
-    connect(): Promise<unknown>;
-    createWebSocketConnection(): Promise<unknown>;
-    onMessage(event: MessageEvent): void;
-    resolveConnectionAttempt(): void;
-    stopConnectionAttempt(): void;
-    rejectConnectionAttempt(): void;
-    checkConnection(): void;
-    registerEventListeners(): void;
-    get serverUrl(): string;
-    get url(): string;
-    disconnect(): void;
-    send(message: any): void;
-    onClose({ event }: onCloseParameters): void;
-    destroy(): void;
-}
+import * as mutex from 'lib0/mutex';
+import type { MessageEvent } from 'ws';
+import { Event } from 'ws';
+import EventEmitter from './EventEmitter.js';
+import { onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, WebSocketStatus, onAwarenessChangeParameters, onAwarenessUpdateParameters } from './types.js';
+import { HocuspocusProvider } from './HocuspocusProvider.js';
+export type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
+export interface CompleteHocuspocusProviderWebsocketConfiguration {
+    /**
+     * URL of your @hocuspocus/server instance
+     */
+    url: string;
+    /**
+     * Pass `false` to start the connection manually.
+     */
+    connect: boolean;
+    /**
+     * URL parameters that should be added.
+     */
+    parameters: {
+        [key: string]: any;
+    };
+    /**
+     * 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 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;
+    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;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
+}
+export declare class HocuspocusProviderWebsocket extends EventEmitter {
+    configuration: CompleteHocuspocusProviderWebsocketConfiguration;
+    subscribedToBroadcastChannel: boolean;
+    webSocket: WebSocket | null;
+    shouldConnect: boolean;
+    status: WebSocketStatus;
+    lastMessageReceived: number;
+    mux: mutex.mutex;
+    intervals: any;
+    connectionAttempt: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    } | 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;
+    boundConnect: () => Promise<unknown>;
+    cancelWebsocketRetry?: () => void;
+    connect(): Promise<unknown>;
+    createWebSocketConnection(): Promise<unknown>;
+    onMessage(event: MessageEvent): void;
+    resolveConnectionAttempt(): void;
+    stopConnectionAttempt(): void;
+    rejectConnectionAttempt(): void;
+    checkConnection(): void;
+    registerEventListeners(): void;
+    get serverUrl(): string;
+    get url(): string;
+    disconnect(): void;
+    send(message: any): void;
+    onClose({ event }: onCloseParameters): void;
+    destroy(): void;
+}

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

@@ -1,16 +1,16 @@
-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;
-    readVarString(): string;
-    readVarUint8Array(): Uint8Array;
-    writeVarUint(type: MessageType): void;
-    writeVarString(string: string): void;
-    writeVarUint8Array(data: Uint8Array): void;
-    length(): number;
-}
+import { Decoder } from 'lib0/decoding';
+import { Encoder } from 'lib0/encoding';
+import { MessageType } from './types.js';
+export declare class IncomingMessage {
+    data: any;
+    encoder: Encoder;
+    decoder: Decoder;
+    constructor(data: any);
+    readVarUint(): MessageType;
+    readVarString(): string;
+    readVarUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    writeVarString(string: string): void;
+    writeVarUint8Array(data: Uint8Array): void;
+    length(): number;
+}

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

@@ -1,13 +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;
-}
+import { HocuspocusProvider } from './HocuspocusProvider.js';
+import { IncomingMessage } from './IncomingMessage.js';
+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

@@ -1,10 +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;
-}
+import { Encoder } from 'lib0/encoding';
+import { ConstructableOutgoingMessage } from './types.js';
+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

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

@@ -1,7 +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;
-}
+import { MessageType, OutgoingMessageArguments } from '../types.js';
+import { OutgoingMessage } from '../OutgoingMessage.js';
+export declare class AuthenticationMessage extends OutgoingMessage {
+    type: MessageType;
+    description: string;
+    get(args: Partial<OutgoingMessageArguments>): import("lib0/encoding").Encoder;
+}

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

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

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

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

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

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

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

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