@lakutata/webrtc 0.0.0-stage → 3.1.4

package/dist/types/cluster/transports/RedisClusterTransport.d.ts

@@ -0,0 +1,23 @@
+import type { Redis } from 'ioredis';
+import type { ClusterRedisTransportOptions } from '../Cluster.js';
+import type { ClusterTransport } from './ClusterTransport.js';
+/**
+ * The bus on a Redis server: its channels (publish and subscribe), on two connections
+ */
+export declare class RedisClusterTransport implements ClusterTransport {
+    #private;
+    protected readonly options: Omit<ClusterRedisTransportOptions, 'type'>;
+    readonly maxPayload: number;
+    constructor(options: Omit<ClusterRedisTransportOptions, 'type'>);
+    connect(): Promise<void>;
+    publish(subject: string, data: Uint8Array): void;
+    subscribe(subject: string, handler: (data: Uint8Array) => void): Promise<void>;
+    onReconnect(listener: () => void): void;
+    close(): Promise<void>;
+    /**
+     * Connect a client, failing with the reason when the server cannot be reached; afterwards, it reconnects by itself
+     * @param client
+     * @protected
+     */
+    protected connected(client: Redis): Promise<void>;
+}

package/dist/types/exceptions/ClusterRequestException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `Cluster.request()` when the request cannot be answered: the node is not in the cluster, it has no handler
+ * of the topic, or its handler failed. Its `errno` is `'E_CLUSTER_REQUEST'`.
+ */
+export declare class ClusterRequestException extends Exception {
+    /**
+     * `'E_CLUSTER_REQUEST'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/ClusterTimeoutException.d.ts

@@ -0,0 +1,10 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown by `Cluster.request()` when the node does not answer in time. Its `errno` is `'E_CLUSTER_TIMEOUT'`.
+ */
+export declare class ClusterTimeoutException extends Exception {
+    /**
+     * `'E_CLUSTER_TIMEOUT'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/ClusterTransportNotFoundException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `Cluster` component starts with a transport whose client package is not installed (`nats` for NATS,
+ * `ioredis` for Redis). Its `errno` is `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+ */
+export declare class ClusterTransportNotFoundException extends Exception {
+    /**
+     * `'E_CLUSTER_TRANSPORT_NOT_FOUND'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/SignalingClientRequiredException.d.ts

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a signaling request comes without a client id: the signaling pushes its events to the clients, so it
+ * needs a transport with clients (Socket.IO, JSON-RPC over WebSocket), not JSON-RPC over HTTP, nor the data channels
+ * of `webrtcServiceEntrypoint`. Its `errno` is `'E_SIGNALING_CLIENT_REQUIRED'`.
+ */
+export declare class SignalingClientRequiredException extends Exception {
+    /**
+     * `'E_SIGNALING_CLIENT_REQUIRED'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/SignalingConnectionException.d.ts

@@ -0,0 +1,12 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when `SignalingClient` cannot use the transport of its URL: Socket.IO (an `http:` or `https:` URL) needs the
+ * package `socket.io-client`, JSON-RPC (a `ws:` or `wss:` URL) needs the global `WebSocket` (Node.js 22 and later,
+ * Bun). Its `errno` is `'E_SIGNALING_CONNECTION'`.
+ */
+export declare class SignalingConnectionException extends Exception {
+    /**
+     * `'E_SIGNALING_CONNECTION'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/SignalingDeniedException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `Signaling` component refuses a member the room it asks to join. Its
+ * `errno` is `'E_SIGNALING_DENIED'`.
+ */
+export declare class SignalingDeniedException extends Exception {
+    /**
+     * `'E_SIGNALING_DENIED'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/SignalingLimitException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a member goes over a limit of the `Signaling` component: the size of a message, the messages per
+ * second, the members of a room. Its `errno` is `'E_SIGNALING_LIMIT'`.
+ */
+export declare class SignalingLimitException extends Exception {
+    /**
+     * `'E_SIGNALING_LIMIT'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/SignalingNotAMemberException.d.ts

@@ -0,0 +1,11 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a member sends a signal in a room it has not joined, or to a member who is not in it. Its `errno` is
+ * `'E_SIGNALING_NOT_A_MEMBER'`.
+ */
+export declare class SignalingNotAMemberException extends Exception {
+    /**
+     * `'E_SIGNALING_NOT_A_MEMBER'`.
+     */
+    errno: string | number;
+}

package/dist/types/exceptions/WHEPDeniedException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `WHEP` component refuses a stream to its viewer (an HTTP 401). Its
+ * `errno` is `'E_WHEP_DENIED'`.
+ */
+export declare class WHEPDeniedException extends Exception {
+    /**
+     * `'E_WHEP_DENIED'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 401.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHEPLimitException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `WHEP` component has as many sessions as its `maxSessions` option allows (an HTTP 503). Its
+ * `errno` is `'E_WHEP_LIMIT'`.
+ */
+export declare class WHEPLimitException extends Exception {
+    /**
+     * `'E_WHEP_LIMIT'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 503.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHEPMediaTypeException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the body of a request to `WHEPController` is not `application/sdp` (a POST) or
+ * `application/trickle-ice-sdpfrag` (a PATCH): an HTTP 415. Its `errno` is `'E_WHEP_MEDIA_TYPE'`.
+ */
+export declare class WHEPMediaTypeException extends Exception {
+    /**
+     * `'E_WHEP_MEDIA_TYPE'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 415.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHEPOfferException.d.ts

@@ -0,0 +1,16 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the offer of a viewer is not one the `WHEP` component can answer: not an SDP offer, without audio
+ * or video, of a room the media server does not serve, or refused by the connection; or when the fragment of a PATCH
+ * has no ICE or is refused (an HTTP 400). Its `errno` is `'E_WHEP_OFFER'`.
+ */
+export declare class WHEPOfferException extends Exception {
+    /**
+     * `'E_WHEP_OFFER'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 400.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHEPSessionNotFoundException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a request to `WHEPController` names a session the `WHEP` component does not have (an HTTP 404). Its
+ * `errno` is `'E_WHEP_SESSION_NOT_FOUND'`.
+ */
+export declare class WHEPSessionNotFoundException extends Exception {
+    /**
+     * `'E_WHEP_SESSION_NOT_FOUND'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 404.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHIPDeniedException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `authorize` option of the `WHIP` component refuses a stream to its publisher (an HTTP 401). Its
+ * `errno` is `'E_WHIP_DENIED'`.
+ */
+export declare class WHIPDeniedException extends Exception {
+    /**
+     * `'E_WHIP_DENIED'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 401.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHIPLimitException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the `WHIP` component has as many sessions as its `maxSessions` option allows (an HTTP 503). Its
+ * `errno` is `'E_WHIP_LIMIT'`.
+ */
+export declare class WHIPLimitException extends Exception {
+    /**
+     * `'E_WHIP_LIMIT'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 503.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHIPMediaTypeException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the body of a request to `WHIPController` is not `application/sdp` (a POST) or
+ * `application/trickle-ice-sdpfrag` (a PATCH): an HTTP 415. Its `errno` is `'E_WHIP_MEDIA_TYPE'`.
+ */
+export declare class WHIPMediaTypeException extends Exception {
+    /**
+     * `'E_WHIP_MEDIA_TYPE'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 415.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHIPOfferException.d.ts

@@ -0,0 +1,16 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when the offer of a publisher is not one the `WHIP` component can answer: not an SDP offer, without audio
+ * or video, of a room the media server does not serve, or refused by the connection; or when the fragment of a PATCH
+ * has no ICE or is refused (an HTTP 400). Its `errno` is `'E_WHIP_OFFER'`.
+ */
+export declare class WHIPOfferException extends Exception {
+    /**
+     * `'E_WHIP_OFFER'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 400.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exceptions/WHIPSessionNotFoundException.d.ts

@@ -0,0 +1,15 @@
+import { Exception } from '@lakutata/core';
+/**
+ * Thrown when a request to `WHIPController` names a session the `WHIP` component does not have (an HTTP 404). Its
+ * `errno` is `'E_WHIP_SESSION_NOT_FOUND'`.
+ */
+export declare class WHIPSessionNotFoundException extends Exception {
+    /**
+     * `'E_WHIP_SESSION_NOT_FOUND'`.
+     */
+    errno: string | number;
+    /**
+     * The HTTP status of the response: 404.
+     */
+    readonly statusCode: number;
+}

package/dist/types/exports/Client.d.ts

@@ -0,0 +1,11 @@
+export * from '../client/SignalingConnection.js';
+export * from '../protocol/SignalingProtocol.js';
+export { SignalingRequestError } from '../shared/SignalingError.js';
+export type { DataChannelOptions, DataChannelLike, PeerConnectionLike, PeerConnectionConfiguration, StreamOf, TrackOf, TransceiverLike } from '../shared/Connections.js';
+export type { EmitterListener } from '../shared/Emitter.js';
+export type { PeerEvents } from '../shared/Peer.js';
+export type { RoomEvents } from '../shared/Room.js';
+export type { JoinOptions, SignalingSessionEvents } from '../shared/SignalingSession.js';
+export type { SocketIOSocketLike, WebSocketLike } from '../shared/Transports.js';
+export { ChunkedChannel, type ChunkableChannel, type ChunkedChannelEvents, type ChunkedChannelOptions } from '../shared/ChunkedChannel.js';
+export { PeerServiceProxy, PeerServiceError, type PeerServiceProxyOptions } from '../shared/PeerServiceProxy.js';

package/dist/types/exports/WebRTC.d.ts

@@ -0,0 +1,48 @@
+export * from '../protocol/SignalingProtocol.js';
+export * from '../cluster/Cluster.js';
+export type { ClusterTURNServer, TURNSelector } from '../cluster/ClusterTURN.js';
+export * from '../exceptions/ClusterRequestException.js';
+export * from '../exceptions/ClusterTimeoutException.js';
+export * from '../exceptions/ClusterTransportNotFoundException.js';
+export { createTURNCredentials, type TURNCredentials } from '../turn/TURNCredentials.js';
+export * from '../turn/TURNServer.js';
+export * from '../signaling/Signaling.js';
+export * from '../signaling/SignalingController.js';
+export * from '../exceptions/SignalingClientRequiredException.js';
+export * from '../exceptions/SignalingDeniedException.js';
+export * from '../exceptions/SignalingLimitException.js';
+export * from '../exceptions/SignalingNotAMemberException.js';
+export * from '../exceptions/SignalingConnectionException.js';
+export * from '../whip/WHIP.js';
+export * from '../whip/WHIPController.js';
+export * from '../exceptions/WHIPDeniedException.js';
+export * from '../exceptions/WHIPLimitException.js';
+export * from '../exceptions/WHIPMediaTypeException.js';
+export * from '../exceptions/WHIPOfferException.js';
+export * from '../exceptions/WHIPSessionNotFoundException.js';
+export * from '../sfu/SFU.js';
+export * from '../whep/WHEP.js';
+export * from '../whep/WHEPController.js';
+export * from '../exceptions/WHEPDeniedException.js';
+export * from '../exceptions/WHEPLimitException.js';
+export * from '../exceptions/WHEPMediaTypeException.js';
+export * from '../exceptions/WHEPOfferException.js';
+export * from '../exceptions/WHEPSessionNotFoundException.js';
+export * from '../peer/PeerConnection.js';
+export * from '../peer/PeerThreads.js';
+export * from '../peer/PeerChannel.js';
+export { MediaTrack, type MediaKind, type MediaTrackEvents, type MediaTrackOptions } from '../peer/MediaTrack.js';
+export { RtpPacket, type RtpPacketInit } from '../peer/RtpPacket.js';
+export { RtpReceiver, RtpSender, RtpTransceiver, type RtpTransceiverDirection } from '../peer/RtpTransceiver.js';
+export * from '../peer/SignalingClient.js';
+export { type ListenerOptions, type DOMEventListener } from '../peer/Events.js';
+export { SignalingRequestError } from '../shared/SignalingError.js';
+export type { DataChannelOptions, PeerConnectionConfiguration } from '../shared/Connections.js';
+export type { EmitterListener } from '../shared/Emitter.js';
+export type { PeerEvents } from '../shared/Peer.js';
+export type { RoomEvents } from '../shared/Room.js';
+export type { JoinOptions, SignalingSessionEvents } from '../shared/SignalingSession.js';
+export { ChunkedChannel, type ChunkableChannel, type ChunkedChannelEvents, type ChunkedChannelOptions } from '../shared/ChunkedChannel.js';
+export * from '../service/WebRTCServiceEntrypoint.js';
+export { PeerServiceProxy, PeerServiceError, type PeerServiceProxyOptions } from '../shared/PeerServiceProxy.js';
+export { setDebugHandler, type DebugHandler } from '../lib/common/log.js';

package/dist/types/lib/common/binary.d.ts

@@ -0,0 +1,51 @@
+export declare function random16(): number;
+export declare function random32(): number;
+export declare function bufferXor(a: Buffer, b: Buffer): Buffer;
+export declare function bufferArrayXor(arr: Buffer[]): Buffer;
+export declare class BitWriter {
+    private bitLength;
+    value: number;
+    constructor(bitLength: number);
+    set(size: number, startIndex: number, value: number): this;
+    get buffer(): Buffer<ArrayBuffer>;
+}
+export declare class BitWriter2 {
+    /**Max 32bit */
+    private bitLength;
+    private _value;
+    offset: bigint;
+    /**
+   * 各valueがオクテットを跨いではならない
+   */
+    constructor(
+    /**Max 32bit */
+    bitLength: number);
+    set(value: number, size?: number): this;
+    get value(): number;
+    get buffer(): Buffer<ArrayBuffer>;
+}
+export declare function getBit(bits: number, startIndex: number, length?: number): number;
+export declare function paddingByte(bits: number): string;
+export declare function paddingBits(bits: number, expectLength: number): string;
+export declare function bufferWriter(bytes: number[], values: (number | bigint)[]): Buffer<ArrayBuffer>;
+export declare function createBufferWriter(bytes: number[], singleBuffer?: boolean): (values: (number | bigint)[]) => Buffer<ArrayBuffer>;
+export declare function bufferWriterLE(bytes: number[], values: (number | bigint)[]): Buffer<ArrayBuffer>;
+export declare function bufferReader(buf: Buffer, bytes: number[]): any[];
+export declare class BufferChain {
+    buffer: Buffer;
+    constructor(size: number);
+    writeInt16BE(value: number, offset?: number | undefined): this;
+    writeUInt8(value: number, offset?: number | undefined): this;
+}
+export declare const dumpBuffer: (data: Buffer) => string;
+export declare function buffer2ArrayBuffer(buf: Buffer): ArrayBuffer | SharedArrayBuffer;
+export declare class BitStream {
+    uint8Array: Buffer;
+    private position;
+    private bitsPending;
+    constructor(uint8Array: Buffer);
+    writeBits(bits: number, value: number): BitStream;
+    readBits(bits: number): number;
+    private _readBits;
+    seekTo(bitPos: number): void;
+}

package/dist/types/lib/common/binaryData.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Declarative binary data encoder / decoder.
+ *
+ * TypeScript port of the subset of `binary-data` used by werift.
+ * https://github.com/reklatsmasters/binary-data
+ * https://github.com/shinyoshiaki/binary-data
+ *
+ * MIT License
+ *
+ * Copyright (c) 2017 Dmitry Tsvettsikh
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+/** Thrown when the input does not contain enough bytes to decode. */
+export declare class NotEnoughDataError extends Error {
+    constructor(expected: number, received: number);
+}
+/** Sequential reader over a single Buffer. Returned buffers share memory with the input. */
+export declare class BinaryReader {
+    private readonly buf;
+    private offset;
+    constructor(buf: Buffer);
+    /** The number of unread bytes. */
+    get length(): number;
+    /** The number of bytes consumed so far. */
+    get bytes(): number;
+    readBuffer(size: number): Buffer;
+    readUIntBE(size: number): number;
+    private assertSize;
+}
+/** Collects written chunks and concatenates them once at the end. */
+export declare class BinaryWriter {
+    private readonly chunks;
+    private written;
+    /** The number of bytes written so far. */
+    get bytes(): number;
+    writeBuffer(buf: Buffer): void;
+    writeUIntBE(value: number, size: number): void;
+    toBuffer(): Buffer;
+}
+/**
+ * Encode / decode context.
+ * `node` is the root object, `current` is the object currently being processed.
+ */
+export interface BinaryContext {
+    node: any;
+    current: any;
+}
+export interface DataType<T> {
+    encode(value: T, writer: BinaryWriter, context: BinaryContext): void;
+    decode(reader: BinaryReader, context: BinaryContext): T;
+}
+export type NumberType = DataType<number>;
+export interface Schema {
+    [key: string]: DataType<any> | Schema;
+}
+export type TypeOrSchema = DataType<any> | Schema;
+/** Infer the decoded value from a type or schema. */
+export type Decoded<S> = S extends DataType<infer T> ? T : S extends Schema ? {
+    -readonly [K in keyof S]: Decoded<S[K]>;
+} : never;
+export type LengthCallback = (context: BinaryContext) => number;
+/** Encode `obj` using a type or schema. */
+export declare function encode(obj: any, typeOrSchema: TypeOrSchema): Buffer;
+/**
+ * Decode `buf` using a type or schema.
+ * Trailing bytes are ignored. Throws NotEnoughDataError when `buf` is too short.
+ */
+export declare function decode<S extends TypeOrSchema>(buf: Buffer, typeOrSchema: S): Decoded<S>;
+type LengthSpec = number | NumberType | LengthCallback;
+/**
+ * Buffer type.
+ * @param length fixed number of bytes, number type for size-prefixed buffers,
+ * or callback returning the number of bytes.
+ */
+declare function buffer(length: LengthSpec): DataType<Buffer>;
+/**
+ * Array type.
+ * @param type type or schema of each item.
+ * @param length fixed length, number type for length-prefixed arrays, or callback.
+ * @param lengthType `count` (number of items) or `bytes` (number of bytes).
+ */
+declare function array<S extends TypeOrSchema>(type: S, length: LengthSpec, lengthType?: 'count' | 'bytes'): DataType<Decoded<S>[]>;
+/**
+ * String type.
+ * @param length fixed number of bytes, number type for size-prefixed strings,
+ * or callback returning the number of bytes.
+ */
+declare function string(length: LengthSpec, encoding?: BufferEncoding): DataType<string>;
+export declare const types: {
+    uint8: NumberType;
+    uint16be: NumberType;
+    uint24be: NumberType;
+    uint32be: NumberType;
+    uint48be: NumberType;
+    buffer: typeof buffer;
+    array: typeof array;
+    string: typeof string;
+};
+export {};

package/dist/types/lib/common/crc.d.ts

@@ -0,0 +1,4 @@
+type Input = string | Buffer | Uint8Array;
+export declare function crc32(input: Input, seed?: number): number;
+export declare function crc32c(input: Input, seed?: number): number;
+export {};

package/dist/types/lib/common/deque.d.ts

@@ -0,0 +1,36 @@
+/**
+ * A double-ended queue on a ring buffer: adding and removing at both ends take constant time, however long it is (a
+ * JavaScript array takes time in proportion to its length to remove its first item)
+ */
+export declare class Deque<T> implements Iterable<T> {
+    #private;
+    /**
+     * The number of items
+     */
+    get length(): number;
+    /**
+     * Adds an item at the end
+     */
+    push(item: T): void;
+    /**
+     * Adds an item at the start
+     */
+    unshift(item: T): void;
+    /**
+     * Removes the first item and returns it; undefined when empty
+     */
+    shift(): T | undefined;
+    /**
+     * The item at a position from the start (a negative position counts from the end); undefined out of range
+     */
+    at(index: number): T | undefined;
+    /**
+     * The position of the first item the predicate accepts; -1 when none does
+     */
+    findIndex(predicate: (item: T) => boolean): number;
+    /**
+     * Removes every item
+     */
+    clear(): void;
+    [Symbol.iterator](): Iterator<T>;
+}

package/dist/types/lib/common/event.d.ts

@@ -0,0 +1,48 @@
+type EventExecute<T extends any[]> = (...args: T) => void;
+type PromiseEventExecute<T extends any[]> = (...args: T) => Promise<void>;
+type EventComplete = () => void;
+type EventError = (e: any) => void;
+export declare class Event<T extends any[]> {
+    private readonly subscribers;
+    private readonly queued;
+    ended: boolean;
+    onended?: () => void;
+    onerror: (_error: any) => void;
+    onsubscriberschange?: () => void;
+    execute: (...args: T) => void;
+    complete: () => void;
+    error: (e: any) => void;
+    allUnsubscribe: () => void;
+    subscribe: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => {
+        unSubscribe: () => void;
+        disposer: (disposer: EventDisposer) => void;
+    };
+    pipe(e: Event<T>): void;
+    queuingSubscribe: (execute: PromiseEventExecute<T>, complete?: EventComplete, error?: EventError) => {
+        unSubscribe: () => void;
+        disposer: (disposer: EventDisposer) => void;
+    };
+    once: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => void;
+    watch: (cb: (...args: T) => boolean, timeLimit?: number) => Promise<T>;
+    asPromise: (timeLimit?: number) => Promise<T>;
+    get returnTrigger(): {
+        execute: (...args: T) => void;
+        error: (e: any) => void;
+        complete: () => void;
+    };
+    get returnListener(): {
+        subscribe: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => {
+            unSubscribe: () => void;
+            disposer: (disposer: EventDisposer) => void;
+        };
+        once: (execute: EventExecute<T>, complete?: EventComplete, error?: EventError) => void;
+        asPromise: (timeLimit?: number) => Promise<T>;
+    };
+    get length(): number;
+}
+export declare class EventDisposer {
+    private _disposer;
+    push(disposer: () => void): void;
+    dispose(): void;
+}
+export {};

package/dist/types/lib/common/index.d.ts

@@ -0,0 +1,11 @@
+export * from './binary.js';
+export * from './crc.js';
+export * from './number.js';
+export * from './promise.js';
+export * from './network.js';
+export * from './type.js';
+export * from './log.js';
+export * from './event.js';
+export * from './transport.js';
+export * as binaryData from './binaryData.js';
+export * from './deque.js';