@hocuspocus/extension-webhook 2.1.0-alpha.0 → 2.1.0

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;
+}

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

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

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

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

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

@@ -1,11 +1,11 @@
-import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
-export interface AdditionalTiptapCollabProviderConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProvider extends HocuspocusProvider {
-    constructor(configuration: TiptapCollabProviderConfiguration);
-}
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
+export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalTiptapCollabProviderConfiguration;
+export interface AdditionalTiptapCollabProviderConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProvider extends HocuspocusProvider {
+    constructor(configuration: TiptapCollabProviderConfiguration);
+}

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

@@ -1,11 +1,11 @@
-import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket';
-export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
-export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
-     */
-    appId: string;
-}
-export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
-}
+import { CompleteHocuspocusProviderWebsocketConfiguration, HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
+export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
+export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
+    /**
+     * A Hocuspocus Cloud App ID, get one here: https://collab.tiptap.dev
+     */
+    appId: string;
+}
+export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
+    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
+}

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

@@ -1,5 +1,5 @@
-export * from './HocuspocusProvider';
-export * from './TiptapCollabProvider';
-export * from './TiptapCollabProviderWebsocket';
-export * from './HocuspocusProviderWebsocket';
-export * from './types';
+export * from './HocuspocusProvider.js';
+export * from './TiptapCollabProvider.js';
+export * from './TiptapCollabProviderWebsocket.js';
+export * from './HocuspocusProviderWebsocket.js';
+export * from './types.js';

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

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

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

@@ -1,71 +1,71 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { IncomingMessage as HTTPIncomingMessage } from 'http';
-import AsyncLock from 'async-lock';
-import WebSocket from 'ws';
-import { CloseEvent } from '@hocuspocus/common';
-import Document from './Document';
-import { Debugger } from './Debugger';
-import { onStatelessPayload } from './types';
-export declare class Connection {
-    webSocket: WebSocket;
-    context: any;
-    document: Document;
-    pingInterval: NodeJS.Timeout;
-    pongReceived: boolean;
-    request: HTTPIncomingMessage;
-    timeout: number;
-    callbacks: any;
-    socketId: string;
-    lock: AsyncLock;
-    readOnly: Boolean;
-    logger: Debugger;
-    /**
-     * Constructor.
-     */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
-    boundClose: (event?: CloseEvent) => void;
-    boundHandleMessage: (data: Uint8Array) => void;
-    boundHandlePong: () => void;
-    handlePong(): void;
-    /**
-     * Set a callback that will be triggered when the connection is closed
-     */
-    onClose(callback: (document: Document, event?: CloseEvent) => void): Connection;
-    /**
-     * Set a callback that will be triggered when an stateless message is received
-     */
-    onStatelessCallback(callback: (payload: onStatelessPayload) => Promise<void>): Connection;
-    /**
-     * Set a callback that will be triggered before an message is handled
-     */
-    beforeHandleMessage(callback: (connection: Connection, update: Uint8Array) => Promise<any>): Connection;
-    /**
-     * Send the given message
-     */
-    send(message: any): void;
-    /**
-     * Send a stateless message with payload
-     */
-    sendStateless(payload: string): void;
-    /**
-     * Graceful wrapper around the WebSocket close method.
-     */
-    close(event?: CloseEvent): void;
-    /**
-     * Check if pong was received and close the connection otherwise
-     * @private
-     */
-    private check;
-    /**
-     * Send the current document awareness to the client, if any
-     * @private
-     */
-    private sendCurrentAwareness;
-    /**
-     * Handle an incoming message
-     * @private
-     */
-    private handleMessage;
-}
-export default Connection;
+/// <reference types="node" />
+/// <reference types="node" />
+import { 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';
+export declare class Connection {
+    webSocket: WebSocket;
+    context: any;
+    document: Document;
+    pingInterval: NodeJS.Timeout;
+    pongReceived: boolean;
+    request: HTTPIncomingMessage;
+    timeout: number;
+    callbacks: any;
+    socketId: string;
+    lock: AsyncLock;
+    readOnly: Boolean;
+    logger: Debugger;
+    /**
+     * Constructor.
+     */
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
+    boundClose: (event?: CloseEvent) => void;
+    boundHandleMessage: (data: Uint8Array) => void;
+    boundHandlePong: () => void;
+    handlePong(): void;
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document, event?: CloseEvent) => void): Connection;
+    /**
+     * Set a callback that will be triggered when an stateless message is received
+     */
+    onStatelessCallback(callback: (payload: onStatelessPayload) => Promise<void>): Connection;
+    /**
+     * Set a callback that will be triggered before an message is handled
+     */
+    beforeHandleMessage(callback: (connection: Connection, update: Uint8Array) => Promise<any>): Connection;
+    /**
+     * Send the given message
+     */
+    send(message: any): void;
+    /**
+     * Send a stateless message with payload
+     */
+    sendStateless(payload: string): void;
+    /**
+     * Graceful wrapper around the WebSocket close method.
+     */
+    close(event?: CloseEvent): void;
+    /**
+     * Check if pong was received and close the connection otherwise
+     * @private
+     */
+    private check;
+    /**
+     * Send the current document awareness to the client, if any
+     * @private
+     */
+    private sendCurrentAwareness;
+    /**
+     * Handle an incoming message
+     * @private
+     */
+    private handleMessage;
+}
+export default Connection;

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

@@ -1,14 +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[];
-    };
-}
+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[];
+    };
+}