@ceeblue/web-utils 1.0.0

package/dist/web-utils.d.ts

@@ -0,0 +1,731 @@
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * BinaryReader allows to read binary data
+ */
+declare class BinaryReader {
+    private _data;
+    private _size;
+    private _position;
+    private _view;
+    constructor(data: BufferSource);
+    data(): Uint8Array;
+    size(): number;
+    available(): number;
+    value(position?: number): number;
+    position(): number;
+    reset(position?: number): void;
+    shrink(available: number): number;
+    next(count?: number): number;
+    read8(): number;
+    read16(): number;
+    read24(): number;
+    read32(): number;
+    readFloat(): number;
+    readDouble(): number;
+    read7Bit(bytes?: number): number;
+    readString(): string;
+    readHex(size: number): string;
+    /**
+     * Read bytes, to convert bytes to string use String.fromCharCode(...reader.read(size))
+     * @param {UInt32} size
+     */
+    read(size?: number): Uint8Array;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * BinaryWriter allows to write data in its binary form
+ */
+declare class BinaryWriter {
+    get view(): DataView;
+    get capacity(): number;
+    private _data;
+    private _size;
+    private _view?;
+    private _isConst?;
+    constructor(dataOrSize?: BufferSource | number, offset?: number, length?: number);
+    data(): Uint8Array;
+    size(): number;
+    next(count?: number): BinaryWriter;
+    clear(size?: number): BinaryWriter;
+    write(data: string | ArrayLike<number>): BinaryWriter;
+    write8(value: number): BinaryWriter;
+    write16(value: number): BinaryWriter;
+    write24(value: number): BinaryWriter;
+    write32(value: number): BinaryWriter;
+    writeFloat(value: number): BinaryWriter;
+    writeDouble(value: number): BinaryWriter;
+    write7Bit(value: number, bytes?: number): BinaryWriter;
+    writeString(value: string): BinaryWriter;
+    writeHex(value: string): BinaryWriter;
+    reserve(size: number): BinaryWriter;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+declare class BitReader {
+    private _data;
+    private _size;
+    private _position;
+    private _bit;
+    constructor(data: BufferSource);
+    data(): Uint8Array;
+    size(): number;
+    available(): number;
+    next(count?: number): number;
+    read(count?: number): number;
+    read8(): number;
+    read16(): number;
+    read24(): number;
+    read32(): number;
+}
+
+/**
+ * Parameters of connections
+ */
+type Params = {
+    /**
+     * Host to connect. Can include port, and accept also an url format with port and path,
+     * it can help to force a path OR try to give a protocol preference
+     */
+    host: string;
+    /**
+     * The name of the stream to join
+     */
+    streamName: string;
+    /**
+     * Optional access token to use to join a private stream
+     */
+    accessToken?: string;
+    /**
+     * iceServer to use while connecting to a WebRTC stream
+     */
+    iceServer?: RTCIceServer;
+    /**
+     * Optional query to add into the generated url of connection
+     */
+    query?: Record<string, string>;
+};
+/**
+ * Type of connection
+ */
+declare enum Type {
+    HESP = "hesp",
+    WEBRTS = "webrts",
+    WEBRTC = "webrtc",
+    META = "meta",
+    DATA = "data"
+}
+/**
+ * Some connection utility functions
+ */
+/**
+ * Build an URL from {@link Type | type} and {@link Params | params}
+ * @param type Type of the connection wanted
+ * @param params Connection parameters
+ * @param protocol Optional parameter to choose the prefered protocol to connect
+ * @returns The URL of connection
+ */
+declare function buildURL(type: Type, params: Params, protocol?: string): URL;
+
+type Connect_Params = Params;
+type Connect_Type = Type;
+declare const Connect_Type: typeof Type;
+declare const Connect_buildURL: typeof buildURL;
+declare namespace Connect {
+  export { type Connect_Params as Params, Connect_Type as Type, Connect_buildURL as buildURL };
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * A advanced EventEmitter which allows to declare event as natural function in the inheriting children class,
+ * function must start by `on` prefix to be recognized as an event.
+ * The function can define a behavior by default, and user can choose to redefine this behavior,
+ * or add an additionnal subscription for this event.
+ * In addition you can unsubscribe to multiple events with an `AbortController`
+ * @example
+ * class Logger extends EventEmitter {
+ *    onLog(log:string) { console.log(log); } // behavior by default
+ *
+ *    test() {
+ *       // raise event onLog
+ *       this.onLog('test');
+ *    }
+ * }
+ *
+ * const logger = new Logger();
+ * logger.test(); // displays a log 'test'
+ *
+ * // redefine default behavior to display nothing
+ * logger.onLog = () => {}
+ * logger.test(); // displays nothing
+ *
+ * // add an additionnal subscription
+ * logger.on('log', console.log);
+ * logger.test(); // displays a log 'test'
+ *
+ * // remove the additionnal subscription
+ * logger.off('log', console.log);
+ * logger.test(); // displays nothing
+ *
+ * // add two additionnal subscriptions with a AbortController
+ * const controller = new AbortController();
+ * logger.on('log', log => console.log(log), controller);
+ * logger.on('log', log => console.error(log), controller);
+ * logger.test(); // displays a log 'test' + an error 'test'
+ *
+ * // Unsubscribe all the subscription with the AbortController
+ * controller.abort();
+ * logger.test(); // displays nothing
+ */
+declare class EventEmitter {
+    private _events;
+    /**
+     * Build our EventEmitter, usually call from children class
+     */
+    constructor();
+    /**
+     * Event subscription
+     * @param name Name of event without the `on` prefix (ex: `log` to `onLog` event declared)
+     * @param event Subscriber Function
+     * @param abort Optional `AbortController` to stop this or multiple subscriptions in same time
+     */
+    on(name: string, event: Function, abort?: AbortController): void;
+    /**
+     * Event subscription only one time, once time fired it's automatically unsubscribe
+     * @param name Name of event without the `on` prefix (ex: `log` to `onLog` event declared)
+     * @param event Subscriber Function
+     * @param abort Optional `AbortController` to stop this or multiple subscriptions in same time
+     */
+    once(name: string, event: Function, abort?: AbortController): void;
+    /**
+     * Event unsubscription
+     * @param name Name of event without the 'on' prefix (ex: 'log' to 'onLog' event declared)
+     * @param event Unsubscriber Function, must be the one passed to {@link on} or {@link once} subscription methods
+     */
+    off(name: string, event: Function): void;
+    private _event;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Implement this interface to throw log and error
+ */
+interface ILog {
+    /**
+     * Call to distribute log message, default implementation is usually `onLog(log:string) { console.log(log); }`
+     * @param log log string message
+     * @event
+     */
+    onLog(log: string): void;
+    /**
+     * Call to distribute error message, default implementation is usually `onError(error:string) { console.error(error); }`
+     * @param error error string message
+     * @event
+     */
+    onError(error: string): void;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Help class to manipulate and parse a net address. The Address can be only the domain field,
+ * or a URL format with protocol and path part `(http://)domain(:port/path)`
+ * @example
+ * const address = new Address('nl-ams-42.live.ceeblue.tv:80');
+ * console.log(address.domain) // 'nl-ams-42.live.ceeblue.tv'
+ * console.log(address.port) // '80'
+ * console.log(address) // 'nl-ams-42.live.ceeblue.tv:80'
+ */
+declare class NetAddress {
+    /**
+     * Static help function to build an end point from an address `(proto://)domain(:port/path)`
+     *
+     * Mainly it fix the protocol, in addition if:
+     *  - the address passed is securized (TLS) and protocol is not => it tries to fix protocol to get its securize version
+     *  - the address passed is non securized and protocol is (TLS) => it tries to fix protocol to get its unsecurized version
+     * @param protocol protocol to set in the end point returned
+     * @param address string address to fix with protocol as indicated
+     * @returns the end point built
+     * @example
+     * console.log(NetAddress.fixProtocol('ws','http://domain/path')) // 'ws://domain/path'
+     * console.log(NetAddress.fixProtocol('ws','https://domain/path')) // 'wss://domain/path'
+     * console.log(NetAddress.fixProtocol('wss','http://domain/path')) // 'ws://domain/path'
+     */
+    static fixProtocol(protocol: string, address: string): string;
+    /**
+     * The domain part from address `(http://)domain(:port/path)`
+     */
+    get domain(): string;
+    /**
+     * The port part from address `(http://)domain(:port/path)`, or defaultPort if passed in NetAddress constructor
+     */
+    get port(): number | undefined;
+    /**
+     * @returns the string address as passed in the constructor
+     */
+    toString(): string;
+    /**
+     * @returns the string address as passed in the constructor
+     * @override
+     */
+    valueOf(): string;
+    private _address;
+    private _domain;
+    private _port?;
+    /**
+     * Build a NetAddress object and parse address
+     * @param address string address to parse, accept an url format with protocol and path `(http://)domain(:port/path)`
+     * @param defaultPort set a default port to use if there is no port in the string address parsed
+     */
+    constructor(address: string, defaultPort?: number);
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Queue typed similar to a {@link https://en.cppreference.com/w/cpp/container/queue | std::queue<Type>} with possibility to limit the capacity like a FIFO
+ * @example
+ * const queue = new Queue<number>(2);
+ * queue.push(1); // [1]
+ * queue.push(2); // [1,2]
+ * queue.push(3); // [2,3] 1 has been removed to respect 2 capacity
+ */
+declare class Queue<Type> {
+    /**
+     * Number of element in the queue
+     */
+    get size(): number;
+    /**
+     * Maximum capacity for the queue, if not set queue has unlimited capacity
+     */
+    get capacity(): number | undefined;
+    /**
+     * Set a maximum capacity for the queue,
+     * if you push new value exceding this capacity the firsts are removed (FIFO)
+     * if set to undefined the queue is unlimited
+     */
+    set capacity(value: number | undefined);
+    /**
+     * The front element
+     */
+    get front(): Type;
+    /**
+     * The back element
+     */
+    get back(): Type;
+    /**
+     * Iterator though queue's elements
+     */
+    [Symbol.iterator](): IterableIterator<Type>;
+    private _capacity?;
+    private _queue;
+    /**
+     * Instanciate a new queue object with the type passed as template
+     * @param capacity if set it limits the size of the queue, any exceding element pops the first element pushed (FIFO)
+     */
+    constructor(capacity?: number);
+    /**
+     * Push a new element in the queue
+     * @param value value of the element
+     * @returns this
+     */
+    push(value: Type): Queue<Type>;
+    /**
+     * Pop the first element from the queue
+     * @returns The first element removed
+     */
+    pop(): Type | undefined;
+    /**
+     * Clear all the elements, queue becomes empty
+     * @returns this
+     */
+    clear(): Queue<Type>;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+
+/**
+ * A collection of number Queue<number> with the following efficient mathematic computation:
+ * - minimum value in the collection
+ * - maximum value in the collection
+ * - average value of the collection
+ */
+declare class Numbers extends Queue<number> {
+    /**
+     * minimum value in the collection, or 0 if colleciton is empty
+     */
+    get minimum(): number;
+    /**
+     * maximum value in the collection, or 0 if colleciton is empty
+     */
+    get maximum(): number;
+    /**
+     * average value of the collection, or 0 if collection if empty
+     */
+    get average(): number;
+    private _average?;
+    private _sum;
+    private _min;
+    private _max;
+    /**
+     * Instantiate the collection of the number
+     * @param capacity if set it limits the number of values stored, any exceding number pops the first number pushed (FIFO)
+     */
+    constructor(capacity?: number);
+    /**
+     * Push a value to the back to the collection
+     * @param value number to add
+     * @returns this
+     */
+    push(value: number): Numbers;
+    /**
+     * Pop the front number from the collection
+     * @returns the front number removed
+     */
+    pop(): number | undefined;
+    /**
+     * Clear all the numbers, collection becomes empty
+     * @returns this
+     */
+    clear(): this;
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Toolkit to deal with Session Description Protocol (SDP),
+ * mainly to tranform a SDP string Offer/Answer to a manipulable JS object representation
+ * @example
+ * const peerConnection = new RTCPeerConnection();
+ * peerConnection.createOffer()
+ * .then( offer =>
+ *    // Change offer.sdp string to a JS manipulable object
+ *    const sdp = SDP.fromString(offer.sdp || '');
+ *    // Change a property of SDP
+ *    sdp.v = 2; // change SDP version
+ *    // Reserialize to the legal SDP string format
+ *    offer.sdp = SDP.toString(sdp);
+ *    // Set SDP offer to peerConnection
+ *    peerConnection.setLocalDescription(offer);
+ * )
+ */
+declare const SDP: {
+    /**
+     * Unserialize SDP string to a manipulable JS object representation
+     * It's an object with:
+     *  - root SDP properties
+     *  - media description iterable
+     * @param lines SDP string reprensentation
+     * @returns SDP object representation, iterable through media description
+     * @example
+     * [
+     *    group: "DUNBLE 0 1",
+     *    o: "- 1699450751193623 0 IN IP4 0.0.0.0",
+     *    s: "-",
+     *    t: "0 0",
+     *    v: "0",
+     *    ice-lite: "",
+     *    length: 2,
+     *    {
+     *       m: "audio 9 UDP/TLS/RTP/SAVPF 111",
+     *       c: "IN IP4 0.0.0.0",
+     *       rtcp: "9",
+     *       sendonly: "",
+     *       setup: "passive",
+     *       fingerprint: "sha-256 51:36:ED:78:A4:9F:25:8C:39:9A:0E:A0:B4:9B:6E:04:37:FF:AD:96:93:71:43:88:2C:0B:0F:AB:6F:9A:52:B8",
+     *       ice-ufrag: "fa37",
+     *       ice-pwd: "JncCHryDsbzayy4cBWDxS2",
+     *       rtcp-mux: "",
+     *       rtcp-rsize: "",
+     *       rtpmap: "111 opus/48000/2",
+     *       rtcp-fb: "111 nack",
+     *       id: "0",
+     *       fmtp: "111 minptime=10;useinbandfec=1",
+     *       candidate: "1 1 udp 2130706431 89.105.221.108 56643 typ host",
+     *       end-of-candidates: ""
+     *    },
+     *    {
+     *       m: "video 9 UDP/TLS/RTP/SAVPF 106",
+     *       c: "IN IP4 0.0.0.0",
+     *       rtcp: "9",
+     *       sendonly: "",
+     *       setup: "passive",
+     *       fingerprint: "sha-256 51:36:ED:78:A4:9F:25:8C:39:9A:0E:A0:B4:9B:6E:04:37:FF:AD:96:93:71:43:88:2C:0B:0F:AB:6F:9A:52:B8",
+     *       ice-ufrag: "fa37",
+     *       ice-pwd: "JncCHryDsbzayy4cBWDxS2",
+     *       rtcp-mux: "",
+     *       rtcp-rsize: "",
+     *       rtpmap: "106 H264/90000",
+     *       rtcp-fb: [
+     *          "106 nack",
+     *          "106 goog-remb"
+     *       ],
+     *       mid: "1",
+     *       fmtp: "106 profile-level-id=42e01f;level-asymmetry-allowed=1;packetization-mode=1",
+     *       candidate: "1 1 udp 2130706431 89.105.221.108 56643 typ host",
+     *       end-of-candidates: ""
+     *    }
+     * ]
+     */
+    fromString(lines: string): any;
+    /**
+     * Serialize SDP JS object to a SDP string legal representation
+     * @param sdp SDP object reprensetation
+     * @returns SDP string reprensentation
+     */
+    toString(sdp: any): string;
+    /**
+     * While set a property to a SDP object representation is possible directly,
+     * we could prefer add a new property without overload a possible already existing value.
+     * This function allows to add a property to our SDP representation:
+     *  - if the key's attribute doesn't exists yet it adds it like a simple JS property sdp[key] = value
+     *  - if the key's attribute exists already it morphs the value to a Array and push it inside
+     * @param sdp the SDP object representation on which added the attribute
+     * @param attribute the string attribut in a format "key:value" or just "key" to add an attribute without value
+     * @returns the key part of the attribute added (or if value is empty it returns the same attribute as passed in argument)
+     */
+    addAttribute(sdp: object, attribute: string): string;
+    /**
+     * While it's possible to delete a attribute manually on the SDP object representation with a delete sdp.key,
+     * we could prefer remove only a value in a sdp.key array containing multiple values.
+     * Like opposite to addAttribute this method allows to remove an unique attribute value.
+     * @param sdp the SDP object representation on which removed the attribute
+     * @param attribute the string attribut in a format "key:value" or just "key" to remove the whole attribute and all its values
+     * @returns the key part of the attribute removed (or if value is empty it returns the same attribute as passed in argument)
+     */
+    removeAttribute(sdp: object, attribute: string): string;
+    /**
+     * Parse an attribute in a format "key:value"
+     * @param attribute string attribute to parse
+     * @returns the {key, value} result, with value undefined if attribute was a "key" without value
+     */
+    parseAttribute(attribute: string): {
+        key: string;
+        value: string | undefined;
+    };
+};
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+/**
+ * Some basic utility functions
+ */
+/**
+ * Version of the library
+ */
+declare const VERSION = "?";
+/**
+ * An empty lambda function, pratical to disable default behavior of function or events which are not expected to be null
+ * @example
+ * console.log = Util.EMPTY_FUNCTION; // disable logs without breaking calls
+ */
+declare const EMPTY_FUNCTION: () => void;
+/**
+ * Efficient and high resolution timestamp in milliseconds elapsed since {@link Util.timeOrigin}
+ */
+declare function time(): number;
+/**
+ * Time origin represents the time when the application has started
+ */
+declare function timeOrigin(): number;
+/**
+ * Parse query and returns it in an easy-to-use Javascript object form
+ * @param urlOrQueryOrSearch string, url, or searchParams containing query. If not set it uses `location.search` to determinate query.
+ * @returns An javascript object containing each option
+ */
+declare function options(urlOrQueryOrSearch?: URL | URLSearchParams | string | object | undefined): object;
+/**
+ * Returns an easy-to-use Javascript object something iterable, such as a Map, Set, or Array
+ * @param value iterable input
+ * @param params.withType `false`, if set it tries to cast string value to a JS number/boolean/undefined/null type.
+ * @param params.noEmptyString `false`, if set it converts empty string value to a true boolean, usefull to allow a `if(result.key)` check for example
+ * @returns An javascript object
+ */
+declare function objectFrom(value: any, params: {
+    withType: boolean;
+    noEmptyString: boolean;
+}): object;
+/**
+ * Converts various data types, such as objects, strings, exceptions, errors,
+ * or numbers, into a string representation. Since it offers a more comprehensive format,
+ * this function is preferred to `JSON.stringify()`.
+ * @param obj Any objects, strings, exceptions, errors, or number
+ * @param params.space `''`, allows to configure space in the string representation
+ * @param params.decimal `2`, allows to choose the number of decimal to display in the string representation
+ * @param params.recursive `false`, allows to serialize recursively every object value,  beware if a value refers to a already parsed value an infinite loop will occur.
+ * @returns the final string representation
+ */
+declare function stringify(obj: any, params?: {
+    space?: string;
+    decimal?: number;
+    recursive?: number;
+}): string;
+declare function toBin(value: string): Uint8Array;
+
+declare const Util_EMPTY_FUNCTION: typeof EMPTY_FUNCTION;
+declare const Util_VERSION: typeof VERSION;
+declare const Util_objectFrom: typeof objectFrom;
+declare const Util_options: typeof options;
+declare const Util_stringify: typeof stringify;
+declare const Util_time: typeof time;
+declare const Util_timeOrigin: typeof timeOrigin;
+declare const Util_toBin: typeof toBin;
+declare namespace Util {
+  export { Util_EMPTY_FUNCTION as EMPTY_FUNCTION, Util_VERSION as VERSION, Util_objectFrom as objectFrom, Util_options as options, Util_stringify as stringify, Util_time as time, Util_timeOrigin as timeOrigin, Util_toBin as toBin };
+}
+
+/**
+ * Copyright 2023 Ceeblue B.V.
+ * This file is part of https://github.com/CeeblueTV/web-utils which is released under GNU Affero General Public License.
+ * See file LICENSE or go to https://spdx.org/licenses/AGPL-3.0-or-later.html for full license details.
+ */
+
+/**
+ * The WebSocketReliable class extends WebSocket to bring up the following improvements:
+ * - Fix all possible unintentional closing ways to get always a related error message, {@link onClose | onClose(error?) event}
+ * - Make possible message sending while connecting. Indeed no need to wait {@link onOpen} before to send message,
+ * you can open the socket and immediately send messages, it will be queue and flushs on connection etablishment
+ * - Make possible a delayed connection, or a reconnection. Indeed you can create an unconnected Websocket instance
+ * without passing any url argument and starts the conneciton more later with {@link WebSocketReliable.open(url) | open(url)} method
+ * - Make possible to control sending/queueing message: send method take an optional queueing=true argument to
+ * queue message rather send it, a futur call to flush will send it. Then queueing getter allows to handle the queue
+ * if need to purge it or remove some queued message. Use it all together can help to prioritize messages or control overload.
+ * @example
+ * const ws = new WebSocketReliable(url);
+ * ws.onClose = (error?:string) => {
+ *    if(error) {
+ *       console.error(error);
+ *    }
+ *    // reconnection attempt every seconds
+ *    setTimeout(() => ws.open(url), 1000);
+ * }
+ * ws.onMessage = (message:string) => {
+ *    console.log(message);
+ * }
+ * ws.send('hello'); // send immediatly a hello message is possible (no need to wait onOpen)
+ */
+declare class WebSocketReliable extends EventEmitter {
+    /**
+     * @event `open` fired when socket is connected
+     */
+    onOpen(): void;
+    /**
+     * @event `message` fired on message reception
+     * @param message can be binary or string.
+     * If you subscribe to the event with message as string type (and not union),
+     * it means that you know that all your messages are distributed in a string format
+     */
+    onMessage(message: ArrayBuffer | string): void;
+    /**
+     * @event `close` fired on websocket close
+     * @param error error description on an improper closure
+     */
+    onClose(error?: string): void;
+    /**
+     * binaryType, fix binary type to arrayBuffer
+     */
+    get binaryType(): BinaryType;
+    /**
+     * url of connection
+     */
+    get url(): string;
+    /**
+     * extensions negociated by the server
+     */
+    get extensions(): string;
+    /**
+     * protocol negociated by the server
+     */
+    get protocol(): string;
+    /**
+     * opened equals true when connection is etablished, in other word when onOpen event is fired
+     */
+    get opened(): boolean;
+    /**
+     * {@link https://developer.mozilla.org/docs/Web/API/WebSocket/readyState | Official websocket readyState}
+     */
+    get readyState(): number;
+    /**
+     * True when connection is closed, in other words when {@link onClose} event is fired
+     * or when WebSocketReliable is build without url (disconnected creation)
+     */
+    get closed(): boolean;
+    /**
+     * The number of bytes of data that were queued during calls to send() but not yet transmitted to the network
+     */
+    get bufferedAmount(): number;
+    /**
+     * Queued messages from a call to send() waiting to be transmit one time websocket connection opened (or with an explicit call to flush() method)
+     */
+    get queueing(): Array<string | ArrayBuffer | ArrayBufferView>;
+    private _opened;
+    private _closed;
+    private _queueing;
+    private _queueingBytes;
+    private _ws?;
+    /**
+     * Create a WebSocketReliable object, and open it if an url is passed in argument
+     * @param url URL of the WebSocket endpoint or null to start the connection later
+     */
+    constructor(url?: string | URL, protocols?: string | string[]);
+    /**
+     * Open a WebSocket connection
+     * @param url url of the websocket endpoint
+     * @returns this
+     */
+    open(url: URL | string, protocols?: string | string[]): this;
+    /**
+     * Send a message
+     * @param message
+     * @param queueing When set it reports the sending to a more later call to flush
+     * @returns this
+     */
+    send(message: string | ArrayBuffer | ArrayBufferView, queueing?: boolean): this;
+    /**
+     * Send queueing messages
+     */
+    flush(): void;
+    /**
+     * Close websocket
+     * @param error the error reason if is not a proper close
+     */
+    close(error?: string): void;
+}
+
+export { BinaryReader, BinaryWriter, BitReader, Connect, EventEmitter, type ILog, NetAddress, Numbers, Queue, SDP, Util, WebSocketReliable };