@lakutata/webrtc 0.0.0-stage → 3.1.1

package/dist/cjs/shared/PeerServiceProxy.d.ts

@@ -0,0 +1,173 @@
+import { type ChunkableChannel } from './ChunkedChannel.js';
+/**
+ * The error of a call of a {@link PeerServiceProxy}: the error the action threw (its `errno`, the whole error object
+ * as `data`), the JSON-RPC error of the request (`code`), `E_PEER_SERVICE_TIMEOUT` and `E_PEER_SERVICE_CLOSED` for
+ * the calls without a response, or `E_PEER_SERVICE_TOO_LARGE` for a request over the size limit, not sent.
+ * @example
+ * ```typescript
+ * import {PeerServiceError, type PeerServiceProxy} from '@lakutata/webrtc/client'
+ *
+ * declare const device: PeerServiceProxy
+ * try {
+ *     await device.invoke({method: 'door.open'})
+ * } catch (error) {
+ *     if (error instanceof PeerServiceError && error.errno === 'E_ACCESS_DENY') console.log('not allowed to open the door')
+ * }
+ * ```
+ */
+export declare class PeerServiceError extends Error {
+    /**
+     * The `errno` of the action's error (`E_ACCESS_DENY`, `E_INVALID_VALUE`…), the JSON-RPC error code when the error
+     * has none, or `E_PEER_SERVICE_TIMEOUT`, `E_PEER_SERVICE_CLOSED` and `E_PEER_SERVICE_TOO_LARGE`.
+     */
+    readonly errno: string | number;
+    /**
+     * The JSON-RPC error code of the response (`-32601` when no action matches, `-32602` for an invalid input…);
+     * `undefined` for the calls without a response.
+     */
+    readonly code?: number;
+    /**
+     * The error the application sent, as it sent it: the properties of the action's error.
+     */
+    readonly data?: unknown;
+    /**
+     * Create the error.
+     * @param message The message.
+     * @param errno The error number.
+     * @param code The JSON-RPC error code.
+     * @param data The error the application sent.
+     */
+    constructor(message: string, errno: string | number, code?: number, data?: unknown);
+}
+/**
+ * The options of a {@link PeerServiceProxy}.
+ */
+export interface PeerServiceProxyOptions {
+    /**
+     * The field of the input sent as the request's method: the `methodField` of the application's
+     * `webrtcServiceEntrypoint`.
+     * @default 'method'
+     */
+    methodField?: string;
+    /**
+     * The size of a response or an event received at most, in bytes: a larger one is dropped (its call then times out).
+     * @default 67108864 (64 MiB)
+     */
+    maxMessageSize?: number;
+    /**
+     * The size of a request sent at most, in bytes, as JSON: a larger call fails at once with
+     * `E_PEER_SERVICE_TOO_LARGE`, since the application drops the requests over its `limit` without knowing which call
+     * they were. The same as the default `limit` of `webrtcServiceEntrypoint`.
+     * @default 10485760 (10 MiB)
+     */
+    maxRequestSize?: number;
+}
+/**
+ * The service actions of another member, called through a data channel to it: the member is a lakutata application
+ * serving its service actions with `webrtcServiceEntrypoint` (its controllers' `@ServiceAction` methods). Create the
+ * channel with the label the application serves (`'service'` by default); the calls wait for it to open. A call is a
+ * request of JSON-RPC 2.0 whose method is the input's `methodField`, and the events the application pushes to this
+ * member (`Entrypoint.notify()` with the member's id, `Entrypoint.broadcast()`) reach the listeners added with `on`.
+ * The messages are cut into chunks as `ChunkedChannel` does, so their size is not limited by the data channel.
+ *
+ * The same in the browsers (`@lakutata/webrtc/client`) and in Node.js (`@lakutata/webrtc`).
+ * @example
+ * ```typescript
+ * import {PeerServiceProxy, type Peer} from '@lakutata/webrtc/client'
+ *
+ * declare const peer: Peer
+ * //The device's action declared with @ServiceAction({method: 'door.status'})
+ * const device: PeerServiceProxy = new PeerServiceProxy(peer.createDataChannel('service'))
+ * device.on('opened', (by: string): void => console.log(`opened by ${by}`))
+ * const status: {open: boolean} = await device.invoke({method: 'door.status', door: 'front'})
+ * ```
+ */
+export declare class PeerServiceProxy {
+    #private;
+    /**
+     * Call the service actions of a member through a data channel to it.
+     * @param channel The data channel: an `RTCDataChannel` in the browsers, a `PeerChannel` in Node.js; ordered and
+     * reliable (the default).
+     * @param options The method field, the size of a message received at most.
+     * @throws {TypeError} When the channel is not ordered.
+     */
+    constructor(channel: ChunkableChannel, options?: PeerServiceProxyOptions);
+    /**
+     * The data channel.
+     */
+    get channel(): ChunkableChannel;
+    /**
+     * Call a service action of the member.
+     * @param input The action's pattern and input: its `methodField` (`method` by default) is sent as the request's
+     * method, the rest as its params.
+     * @param timeout How long to wait for the response, in milliseconds (the time to open the channel included).
+     * @returns The action's result.
+     * @throws {PeerServiceError} The error of the action or of the request, `E_PEER_SERVICE_TIMEOUT` and
+     * `E_PEER_SERVICE_CLOSED` when no response came, or `E_PEER_SERVICE_TOO_LARGE` when the request is over
+     * `maxRequestSize` (it is not sent).
+     * @throws {TypeError} When the input's `methodField` is not a string.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * //The request {"jsonrpc": "2.0", "id": 1, "method": "light.set", "params": {"room": "hall", "on": true}}
+     * await device.invoke({method: 'light.set', room: 'hall', on: true}, 5000)
+     * ```
+     */
+    invoke<T = any>(input: Record<string, unknown>, timeout?: number): Promise<T>;
+    /**
+     * Listen to an event the application pushes to this member.
+     * @param event The event's name.
+     * @param listener Called with the event's arguments.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * //entrypoint.notify(<this member's id>, 'progress', 50) in the application
+     * device.on('progress', (percent: number): void => console.log(`${percent}%`))
+     * ```
+     */
+    on(event: string, listener: (...args: any[]) => void): this;
+    /**
+     * Listen to the next push of an event only.
+     * @param event The event's name.
+     * @param listener Called with the event's arguments.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.once('ready', (): void => console.log('the device is ready'))
+     * ```
+     */
+    once(event: string, listener: (...args: any[]) => void): this;
+    /**
+     * Remove a listener of an event, or all of them.
+     * @param event The event's name.
+     * @param listener The listener; all the listeners of the event without it.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.off('progress')
+     * ```
+     */
+    off(event: string, listener?: (...args: any[]) => void): this;
+    /**
+     * Close the data channel: the calls waiting for their response fail with `E_PEER_SERVICE_CLOSED`.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.close()
+     * ```
+     */
+    close(): void;
+}

package/dist/cjs/shared/PeerServiceProxy.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeerServiceProxy = exports.PeerServiceError = void 0;
+const ChunkedChannel_js_1 = require("./ChunkedChannel.js");
+/**
+ * The error of a call of a {@link PeerServiceProxy}: the error the action threw (its `errno`, the whole error object
+ * as `data`), the JSON-RPC error of the request (`code`), `E_PEER_SERVICE_TIMEOUT` and `E_PEER_SERVICE_CLOSED` for
+ * the calls without a response, or `E_PEER_SERVICE_TOO_LARGE` for a request over the size limit, not sent.
+ * @example
+ * ```typescript
+ * import {PeerServiceError, type PeerServiceProxy} from '@lakutata/webrtc/client'
+ *
+ * declare const device: PeerServiceProxy
+ * try {
+ *     await device.invoke({method: 'door.open'})
+ * } catch (error) {
+ *     if (error instanceof PeerServiceError && error.errno === 'E_ACCESS_DENY') console.log('not allowed to open the door')
+ * }
+ * ```
+ */
+class PeerServiceError extends Error {
+    /**
+     * Create the error.
+     * @param message The message.
+     * @param errno The error number.
+     * @param code The JSON-RPC error code.
+     * @param data The error the application sent.
+     */
+    constructor(message, errno, code, data) {
+        super(message);
+        this.name = 'PeerServiceError';
+        this.errno = errno;
+        this.code = code;
+        this.data = data;
+    }
+}
+exports.PeerServiceError = PeerServiceError;
+/**
+ * The service actions of another member, called through a data channel to it: the member is a lakutata application
+ * serving its service actions with `webrtcServiceEntrypoint` (its controllers' `@ServiceAction` methods). Create the
+ * channel with the label the application serves (`'service'` by default); the calls wait for it to open. A call is a
+ * request of JSON-RPC 2.0 whose method is the input's `methodField`, and the events the application pushes to this
+ * member (`Entrypoint.notify()` with the member's id, `Entrypoint.broadcast()`) reach the listeners added with `on`.
+ * The messages are cut into chunks as `ChunkedChannel` does, so their size is not limited by the data channel.
+ *
+ * The same in the browsers (`@lakutata/webrtc/client`) and in Node.js (`@lakutata/webrtc`).
+ * @example
+ * ```typescript
+ * import {PeerServiceProxy, type Peer} from '@lakutata/webrtc/client'
+ *
+ * declare const peer: Peer
+ * //The device's action declared with @ServiceAction({method: 'door.status'})
+ * const device: PeerServiceProxy = new PeerServiceProxy(peer.createDataChannel('service'))
+ * device.on('opened', (by: string): void => console.log(`opened by ${by}`))
+ * const status: {open: boolean} = await device.invoke({method: 'door.status', door: 'front'})
+ * ```
+ */
+class PeerServiceProxy {
+    #channel;
+    #chunked;
+    #methodField;
+    #maxRequestSize;
+    #pending = new Map();
+    #listeners = new Map();
+    #opened;
+    #nextId = 1;
+    #closed = false;
+    /**
+     * Call the service actions of a member through a data channel to it.
+     * @param channel The data channel: an `RTCDataChannel` in the browsers, a `PeerChannel` in Node.js; ordered and
+     * reliable (the default).
+     * @param options The method field, the size of a message received at most.
+     * @throws {TypeError} When the channel is not ordered.
+     */
+    constructor(channel, options = {}) {
+        this.#channel = channel;
+        this.#methodField = options.methodField ?? 'method';
+        this.#maxRequestSize = options.maxRequestSize ?? 10 * 1024 * 1024;
+        this.#chunked = new ChunkedChannel_js_1.ChunkedChannel(channel, { ...options.maxMessageSize === undefined ? {} : { maxMessageSize: options.maxMessageSize } });
+        this.#chunked.on('message', (data) => this.#receive(data));
+        this.#opened = new Promise((resolve) => {
+            if (channel.readyState === 'open')
+                return resolve();
+            const opened = () => {
+                channel.removeEventListener('open', opened);
+                resolve();
+            };
+            channel.addEventListener('open', opened);
+        });
+        const closed = () => {
+            channel.removeEventListener('close', closed);
+            this.#close();
+        };
+        channel.addEventListener('close', closed);
+        if (channel.readyState === 'closed')
+            this.#close();
+    }
+    /**
+     * The data channel.
+     */
+    get channel() {
+        return this.#channel;
+    }
+    /**
+     * Call a service action of the member.
+     * @param input The action's pattern and input: its `methodField` (`method` by default) is sent as the request's
+     * method, the rest as its params.
+     * @param timeout How long to wait for the response, in milliseconds (the time to open the channel included).
+     * @returns The action's result.
+     * @throws {PeerServiceError} The error of the action or of the request, `E_PEER_SERVICE_TIMEOUT` and
+     * `E_PEER_SERVICE_CLOSED` when no response came, or `E_PEER_SERVICE_TOO_LARGE` when the request is over
+     * `maxRequestSize` (it is not sent).
+     * @throws {TypeError} When the input's `methodField` is not a string.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * //The request {"jsonrpc": "2.0", "id": 1, "method": "light.set", "params": {"room": "hall", "on": true}}
+     * await device.invoke({method: 'light.set', room: 'hall', on: true}, 5000)
+     * ```
+     */
+    invoke(input, timeout = 10 * 60 * 1000) {
+        const { [this.#methodField]: method, ...params } = input;
+        if (typeof method !== 'string')
+            throw new TypeError(`The input has no method: its field ${this.#methodField} is not a string`);
+        if (this.#closed)
+            return Promise.reject(new PeerServiceError('The channel is closed', 'E_PEER_SERVICE_CLOSED'));
+        const id = this.#nextId++;
+        const request = JSON.stringify({ jsonrpc: '2.0', id: id, method: method, params: params });
+        const size = new TextEncoder().encode(request).byteLength;
+        if (size > this.#maxRequestSize)
+            return Promise.reject(new PeerServiceError(`The request of ${method} is ${size} bytes, over ${this.#maxRequestSize}`, 'E_PEER_SERVICE_TOO_LARGE'));
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new PeerServiceError(`No response to ${method} in ${timeout} ms`, 'E_PEER_SERVICE_TIMEOUT'));
+            }, timeout);
+            this.#pending.set(id, { resolve: resolve, reject: reject, timer: timer });
+            this.#opened.then(() => {
+                if (!this.#pending.has(id))
+                    return Promise.resolve();
+                return this.#chunked.send(request);
+            }).catch(() => this.#settle(id, undefined, new PeerServiceError('The channel is closed', 'E_PEER_SERVICE_CLOSED')));
+        });
+    }
+    /**
+     * Listen to an event the application pushes to this member.
+     * @param event The event's name.
+     * @param listener Called with the event's arguments.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * //entrypoint.notify(<this member's id>, 'progress', 50) in the application
+     * device.on('progress', (percent: number): void => console.log(`${percent}%`))
+     * ```
+     */
+    on(event, listener) {
+        let listeners = this.#listeners.get(event);
+        if (!listeners) {
+            listeners = new Set();
+            this.#listeners.set(event, listeners);
+        }
+        listeners.add(listener);
+        return this;
+    }
+    /**
+     * Listen to the next push of an event only.
+     * @param event The event's name.
+     * @param listener Called with the event's arguments.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.once('ready', (): void => console.log('the device is ready'))
+     * ```
+     */
+    once(event, listener) {
+        const wrapper = (...args) => {
+            this.off(event, wrapper);
+            listener(...args);
+        };
+        return this.on(event, wrapper);
+    }
+    /**
+     * Remove a listener of an event, or all of them.
+     * @param event The event's name.
+     * @param listener The listener; all the listeners of the event without it.
+     * @returns The proxy.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.off('progress')
+     * ```
+     */
+    off(event, listener) {
+        if (listener) {
+            this.#listeners.get(event)?.delete(listener);
+        }
+        else {
+            this.#listeners.delete(event);
+        }
+        return this;
+    }
+    /**
+     * Close the data channel: the calls waiting for their response fail with `E_PEER_SERVICE_CLOSED`.
+     * @example
+     * ```typescript
+     * import type {PeerServiceProxy} from '@lakutata/webrtc/client'
+     *
+     * declare const device: PeerServiceProxy
+     * device.close()
+     * ```
+     */
+    close() {
+        this.#chunked.close();
+        this.#close();
+    }
+    /**
+     * The channel is closed: the calls fail
+     */
+    #close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const id of [...this.#pending.keys()])
+            this.#settle(id, undefined, new PeerServiceError('The channel is closed', 'E_PEER_SERVICE_CLOSED'));
+    }
+    /**
+     * End a call
+     * @param id
+     * @param result
+     * @param error
+     */
+    #settle(id, result, error) {
+        const call = this.#pending.get(id);
+        if (!call)
+            return;
+        this.#pending.delete(id);
+        clearTimeout(call.timer);
+        if (error)
+            return call.reject(error);
+        call.resolve(result);
+    }
+    /**
+     * A message of the application: responses, events
+     * @param data
+     */
+    #receive(data) {
+        if (typeof data !== 'string')
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(data);
+        }
+        catch {
+            return;
+        }
+        for (const entry of Array.isArray(parsed) ? parsed : [parsed]) {
+            if (!entry || typeof entry !== 'object')
+                continue;
+            const { id, result, error, method, params } = entry;
+            if (typeof method === 'string' && id === undefined) {
+                this.#event(method, Array.isArray(params) ? params : params === undefined ? [] : [params]);
+            }
+            else if (typeof id === 'number') {
+                if (!error) {
+                    this.#settle(id, result);
+                    continue;
+                }
+                const remote = error.data && typeof error.data === 'object' ? error.data : {};
+                const message = remote.errMsg ?? remote.message ?? error.message;
+                const code = typeof error.code === 'number' ? error.code : undefined;
+                const errno = remote.errno ?? code ?? 'E_PEER_SERVICE';
+                this.#settle(id, undefined, new PeerServiceError(typeof message === 'string' ? message : 'The call failed', errno, code, error.data));
+            }
+        }
+    }
+    /**
+     * Call the listeners of an event; a listener throwing is reported as an uncaught error and does not stop the others
+     * @param event
+     * @param args
+     */
+    #event(event, args) {
+        for (const listener of [...this.#listeners.get(event) ?? []]) {
+            try {
+                listener(...args);
+            }
+            catch (error) {
+                queueMicrotask(() => {
+                    throw error;
+                });
+            }
+        }
+    }
+}
+exports.PeerServiceProxy = PeerServiceProxy;

package/dist/cjs/shared/Room.d.ts

@@ -0,0 +1,143 @@
+import { type SignalingPeer, type SignalingPeerEvent, type SignalingPeerLeftEvent, type SignalingSignalEvent, type SignalingStream } from '../protocol/SignalingProtocol.js';
+import type { PeerConnectionConfiguration, PeerConnectionLike, StreamOf, TrackOf } from './Connections.js';
+import { Emitter, type EmitterListener } from './Emitter.js';
+import { Peer, type PeerSignal } from './Peer.js';
+/**
+ * The events of a {@link Room}.
+ */
+export type RoomEvents<Connection extends PeerConnectionLike<any>> = {
+    /**
+     * A member to connect to: each member already in the room when it was joined, then each member joining it. A
+     * listener added later is called at once for the peers already there.
+     */
+    peer: [peer: Peer<Connection>];
+    /**
+     * A peer was closed: its member left, its connection was lost for good, or the local member or the member is
+     * connected to another media server (a new peer of the member follows).
+     */
+    'peer-left': [peer: Peer<Connection>];
+    /**
+     * The room was left.
+     */
+    close: [];
+    /**
+     * A peer could not be created, or a peer failed to negotiate.
+     */
+    error: [error: Error, peer?: Peer<Connection>];
+};
+/**
+ * What a room needs of its signaling session
+ */
+export interface RoomHost<Connection extends PeerConnectionLike<any>> {
+    readonly localId: string;
+    readonly signalingUp: boolean;
+    create(configuration?: PeerConnectionConfiguration): Connection | Promise<Connection>;
+    send(room: string, to: string, signal: PeerSignal): Promise<void>;
+    leave(room: Room<Connection>): Promise<void>;
+    rejoin(room: Room<Connection>): void;
+}
+/**
+ * A room joined through the signaling: its {@link Peer}s, one for each other member. Listen to `peer` to use each of
+ * them (create its data channels, listen to its channels and its tracks), to `peer-left` for the ones closed; publish
+ * the tracks sent to every member with `publish()`.
+ *
+ * The members are connected peer to peer, or, in a room with a media server (its `sfu`), each member to the server
+ * only: the server forwards the tracks published to the other members, and the room and its peers work as without it.
+ */
+export declare class Room<Connection extends PeerConnectionLike<any> = PeerConnectionLike> extends Emitter<RoomEvents<Connection>> {
+    #private;
+    /**
+     * The name of the room.
+     */
+    readonly name: string;
+    /**
+     * Create a room (by the signaling session joining it).
+     * @param host The session.
+     * @param name The room.
+     * @param metadata The metadata the local member joined with.
+     */
+    constructor(host: RoomHost<Connection>, name: string, metadata: unknown);
+    /**
+     * The peers whose connection is created.
+     */
+    get peers(): Peer<Connection>[];
+    /**
+     * The metadata the local member joined with.
+     */
+    get metadata(): unknown;
+    /**
+     * Whether the room was left.
+     */
+    get left(): boolean;
+    /**
+     * The id of the media server of the room, when it has one: the members are connected to it, not to each other.
+     */
+    get sfu(): string | undefined;
+    /**
+     * The peer of a member.
+     * @param id The member's id.
+     * @returns The peer, or undefined when the member is not in the room or its connection is not created yet.
+     */
+    peer(id: string): Peer<Connection> | undefined;
+    /**
+     * A stream received through the media server of the room: the member sending it, and its id on the connection of
+     * that member (`event.streams` of a track carries the ids of the connection to the server).
+     * @param id The id of the stream on the connection to the server.
+     * @returns The stream, or undefined when the room has no media server or the stream is not known.
+     */
+    streamOf(id: string): SignalingStream | undefined;
+    /**
+     * Send a track to every member of the room, those joining later too: on each connection, or once to the media
+     * server of the room. A track published after `unpublish()` takes the transceiver of a track unpublished.
+     * @param track The track: a `MediaStreamTrack` in the browsers, a `MediaTrack` in Node.js.
+     * @param streams Its streams (a `MediaStream` in the browsers, its id in Node.js): the members group the tracks of
+     * a stream (to play the audio and the video together).
+     * @returns Resolves once the track is added to the connections.
+     */
+    publish(track: TrackOf<Connection>, ...streams: StreamOf<Connection>[]): Promise<void>;
+    /**
+     * Stop sending a track published: its transceivers stay, inactive, for the next track published.
+     * @param track The track.
+     * @returns Resolves once the track is taken out of the connections.
+     */
+    unpublish(track: TrackOf<Connection>): Promise<void>;
+    /**
+     * Add a listener of an event; a listener of `peer` is called at once for the peers already there.
+     * @param event The event.
+     * @param listener The listener.
+     * @returns This room.
+     */
+    on<Event extends keyof RoomEvents<Connection>>(event: Event, listener: EmitterListener<RoomEvents<Connection>[Event]>): this;
+    /**
+     * Leave the room: its peers are closed.
+     * @returns Resolves once the server is told.
+     */
+    leave(): Promise<void>;
+    /**
+     * The members in the room when it was joined, or joined again after a reconnection of the signaling: the peers of
+     * the members not there any more are dropped (unless their connection is up), the new members get a peer
+     * @param peers
+     * @param metadata
+     * @param sfu The media server of the room, when it has one.
+     * @internal
+     */
+    members(peers: SignalingPeer[], metadata: unknown, sfu?: string): void;
+    /**
+     * A member joined (or joined again)
+     * @param event
+     * @internal
+     */
+    joined(event: SignalingPeerEvent): void;
+    /**
+     * A member left
+     * @param event
+     * @internal
+     */
+    departed(event: SignalingPeerLeftEvent): void;
+    /**
+     * A signal from a member
+     * @param event
+     * @internal
+     */
+    signal(event: SignalingSignalEvent): void;
+}