@runlith/tagma 0.0.0-stage → 0.1.0

package/types/undici/mock-interceptor.d.ts

@@ -0,0 +1,60 @@
+import { IncomingHttpHeaders } from './header';
+import Dispatcher from './dispatcher';
+import { BodyInit, Headers } from './fetch';
+declare class MockScope<TData extends object = object> {
+    constructor(mockDispatch: MockInterceptor.MockDispatch<TData>);
+    delay(waitInMs: number): MockScope<TData>;
+    persist(): MockScope<TData>;
+    times(repeatTimes: number): MockScope<TData>;
+}
+declare class MockInterceptor {
+    constructor(options: MockInterceptor.Options, mockDispatches: MockInterceptor.MockDispatch[]);
+    reply<TData extends object = object>(replyOptionsCallback: MockInterceptor.MockReplyOptionsCallback<TData>): MockScope<TData>;
+    reply<TData extends object = object>(statusCode: number, data?: TData | Buffer | string | MockInterceptor.MockResponseDataHandler<TData>, responseOptions?: MockInterceptor.MockResponseOptions): MockScope<TData>;
+    replyWithError<TError extends Error = Error>(error: TError): MockScope;
+    defaultReplyHeaders(headers: IncomingHttpHeaders): MockInterceptor;
+    defaultReplyTrailers(trailers: Record<string, string>): MockInterceptor;
+    replyContentLength(): MockInterceptor;
+}
+declare namespace MockInterceptor {
+    export interface Options {
+        path: string | RegExp | ((path: string) => boolean);
+        method?: string | RegExp | ((method: string) => boolean);
+        body?: string | RegExp | ((body: string) => boolean);
+        headers?: Record<string, string | RegExp | ((body: string) => boolean)> | ((headers: Record<string, string>) => boolean);
+        query?: Record<string, any>;
+    }
+    export interface MockDispatch<TData extends object = object, TError extends Error = Error> extends Options {
+        times: number | null;
+        persist: boolean;
+        consumed: boolean;
+        data: MockDispatchData<TData, TError>;
+    }
+    export interface MockDispatchData<TData extends object = object, TError extends Error = Error> extends MockResponseOptions {
+        error: TError | null;
+        statusCode?: number;
+        data?: TData | string;
+    }
+    export interface MockResponseOptions {
+        headers?: IncomingHttpHeaders;
+        trailers?: Record<string, string>;
+    }
+    export interface MockResponseCallbackOptions {
+        path: string;
+        method: string;
+        headers?: Headers | Record<string, string>;
+        origin?: string;
+        body?: BodyInit | Dispatcher.DispatchOptions['body'] | null;
+    }
+    export type MockResponseDataHandler<TData extends object = object> = (opts: MockResponseCallbackOptions) => TData | Buffer | string;
+    export type MockReplyOptionsCallback<TData extends object = object> = (opts: MockResponseCallbackOptions) => {
+        statusCode: number;
+        data?: TData | Buffer | string;
+        responseOptions?: MockResponseOptions;
+    };
+}
+interface Interceptable extends Dispatcher {
+    intercept(options: MockInterceptor.Options): MockInterceptor;
+    cleanMocks(): void;
+}
+export { Interceptable, MockInterceptor, MockScope };

package/types/undici/mock-pool.d.ts

@@ -0,0 +1,17 @@
+import Pool from './pool';
+import MockAgent from './mock-agent';
+import { Interceptable, MockInterceptor } from './mock-interceptor';
+import Dispatcher from './dispatcher';
+export default MockPool;
+declare class MockPool extends Pool implements Interceptable {
+    constructor(origin: string, options: MockPool.Options);
+    intercept(options: MockInterceptor.Options): MockInterceptor;
+    dispatch(options: Dispatcher.DispatchOptions, handlers: Dispatcher.DispatchHandler): boolean;
+    close(): Promise<void>;
+    cleanMocks(): void;
+}
+declare namespace MockPool {
+    export interface Options extends Pool.Options {
+        agent: MockAgent;
+    }
+}

package/types/undici/patch.d.ts

@@ -0,0 +1,21 @@
+/// <reference path="../node/index.d.ts" />
+export interface EventInit {
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+export interface EventListenerOptions {
+    capture?: boolean;
+}
+export interface AddEventListenerOptions extends EventListenerOptions {
+    once?: boolean;
+    passive?: boolean;
+    signal?: AbortSignal;
+}
+export type EventListenerOrEventListenerObject = EventListener | EventListenerObject;
+export interface EventListenerObject {
+    handleEvent(object: Event): void;
+}
+export interface EventListener {
+    (evt: Event): void;
+}

package/types/undici/pool-stats.d.ts

@@ -0,0 +1,11 @@
+import Pool from './pool';
+export default PoolStats;
+declare class PoolStats {
+    constructor(pool: Pool);
+    connected: number;
+    free: number;
+    pending: number;
+    queued: number;
+    running: number;
+    size: number;
+}

package/types/undici/pool.d.ts

@@ -0,0 +1,25 @@
+import Client from './client';
+import TPoolStats from './pool-stats';
+import { URL } from 'node:url';
+import Dispatcher from './dispatcher';
+export default Pool;
+type PoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+declare class Pool extends Dispatcher {
+    constructor(url: string | URL, options?: Pool.Options);
+    closed: boolean;
+    destroyed: boolean;
+    readonly stats: TPoolStats;
+    override connect(options: PoolConnectOptions): Promise<Dispatcher.ConnectData>;
+    override connect(options: PoolConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+declare namespace Pool {
+    export type PoolStats = TPoolStats;
+    export interface Options extends Client.Options {
+        factory?(origin: URL, opts: object): Dispatcher;
+        connections?: number | null;
+        clientTtl?: number | null;
+        interceptors?: {
+            Pool?: readonly Dispatcher.DispatchInterceptor[];
+        } & Client.Options['interceptors'];
+    }
+}

package/types/undici/proxy-agent.d.ts

@@ -0,0 +1,22 @@
+import Agent from './agent';
+import buildConnector from './connector';
+import Dispatcher from './dispatcher';
+import { IncomingHttpHeaders } from './header';
+export default ProxyAgent;
+declare class ProxyAgent extends Dispatcher {
+    constructor(options: ProxyAgent.Options | string);
+    dispatch(options: Agent.DispatchOptions, handler: Dispatcher.DispatchHandler): boolean;
+    close(): Promise<void>;
+}
+declare namespace ProxyAgent {
+    export interface Options extends Agent.Options {
+        uri: string;
+        auth?: string;
+        token?: string;
+        headers?: IncomingHttpHeaders;
+        requestTls?: buildConnector.BuildOptions;
+        proxyTls?: buildConnector.BuildOptions;
+        clientFactory?(origin: URL, opts: object): Dispatcher;
+        proxyTunnel?: boolean;
+    }
+}

package/types/undici/readable.d.ts

@@ -0,0 +1,24 @@
+import { Readable } from 'node:stream';
+import { Blob } from 'node:buffer';
+export default BodyReadable;
+declare class BodyReadable extends Readable {
+    constructor(opts: {
+        resume: (this: Readable, size: number) => void | null;
+        abort: () => void | null;
+        contentType?: string;
+        contentLength?: number;
+        highWaterMark?: number;
+    });
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    blob(): Promise<Blob>;
+    bytes(): Promise<Uint8Array>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    formData(): Promise<never>;
+    readonly bodyUsed: boolean;
+    readonly body: never | undefined;
+    dump(opts?: {
+        limit: number;
+        signal?: AbortSignal;
+    }): Promise<void>;
+}

package/types/undici/retry-agent.d.ts

@@ -0,0 +1,6 @@
+import Dispatcher from './dispatcher';
+import RetryHandler from './retry-handler';
+export default RetryAgent;
+declare class RetryAgent extends Dispatcher {
+    constructor(dispatcher: Dispatcher, options?: RetryHandler.RetryOptions);
+}

package/types/undici/retry-handler.d.ts

@@ -0,0 +1,41 @@
+import Dispatcher from './dispatcher';
+export default RetryHandler;
+declare class RetryHandler implements Dispatcher.DispatchHandler {
+    constructor(options: Dispatcher.DispatchOptions & {
+        retryOptions?: RetryHandler.RetryOptions;
+    }, retryHandlers: RetryHandler.RetryHandlers);
+}
+declare namespace RetryHandler {
+    export type RetryState = {
+        counter: number;
+    };
+    export type RetryContext = {
+        state: RetryState;
+        opts: Dispatcher.DispatchOptions & {
+            retryOptions?: RetryHandler.RetryOptions;
+        };
+    };
+    export type OnRetryCallback = (result?: Error | null) => void;
+    export type RetryCallback = (err: Error, context: {
+        state: RetryState;
+        opts: Dispatcher.DispatchOptions & {
+            retryOptions?: RetryHandler.RetryOptions;
+        };
+    }, callback: OnRetryCallback) => void;
+    export interface RetryOptions {
+        throwOnError?: boolean;
+        retry?: RetryCallback;
+        maxRetries?: number;
+        maxTimeout?: number;
+        minTimeout?: number;
+        timeoutFactor?: number;
+        retryAfter?: boolean;
+        methods?: Dispatcher.HttpMethod[];
+        errorCodes?: string[];
+        statusCodes?: number[];
+    }
+    export interface RetryHandlers {
+        dispatch: Dispatcher['dispatch'];
+        handler: Dispatcher.DispatchHandler;
+    }
+}

package/types/undici/round-robin-pool.d.ts

@@ -0,0 +1,25 @@
+import Client from './client';
+import TPoolStats from './pool-stats';
+import { URL } from 'node:url';
+import Dispatcher from './dispatcher';
+export default RoundRobinPool;
+type RoundRobinPoolConnectOptions = Omit<Dispatcher.ConnectOptions, 'origin'>;
+declare class RoundRobinPool extends Dispatcher {
+    constructor(url: string | URL, options?: RoundRobinPool.Options);
+    closed: boolean;
+    destroyed: boolean;
+    readonly stats: TPoolStats;
+    override connect(options: RoundRobinPoolConnectOptions): Promise<Dispatcher.ConnectData>;
+    override connect(options: RoundRobinPoolConnectOptions, callback: (err: Error | null, data: Dispatcher.ConnectData) => void): void;
+}
+declare namespace RoundRobinPool {
+    export type RoundRobinPoolStats = TPoolStats;
+    export interface Options extends Client.Options {
+        factory?(origin: URL, opts: object): Dispatcher;
+        connections?: number | null;
+        clientTtl?: number | null;
+        interceptors?: {
+            RoundRobinPool?: readonly Dispatcher.DispatchInterceptor[];
+        } & Client.Options['interceptors'];
+    }
+}

package/types/undici/snapshot-agent.d.ts

@@ -0,0 +1,98 @@
+import MockAgent from './mock-agent';
+declare class SnapshotRecorder {
+    constructor(options?: SnapshotRecorder.Options);
+    record(requestOpts: any, response: any): Promise<void>;
+    findSnapshot(requestOpts: any): SnapshotRecorder.Snapshot | undefined;
+    loadSnapshots(filePath?: string): Promise<void>;
+    saveSnapshots(filePath?: string): Promise<void>;
+    clear(): void;
+    getSnapshots(): SnapshotRecorder.Snapshot[];
+    size(): number;
+    resetCallCounts(): void;
+    deleteSnapshot(requestOpts: any): boolean;
+    getSnapshotInfo(requestOpts: any): SnapshotRecorder.SnapshotInfo | null;
+    replaceSnapshots(snapshotData: SnapshotRecorder.SnapshotData[]): void;
+    destroy(): void;
+}
+declare namespace SnapshotRecorder {
+    type SnapshotRecorderMode = 'record' | 'playback' | 'update';
+    export interface Options {
+        snapshotPath?: string;
+        mode?: SnapshotRecorderMode;
+        maxSnapshots?: number;
+        autoFlush?: boolean;
+        flushInterval?: number;
+        matchHeaders?: string[];
+        ignoreHeaders?: string[];
+        excludeHeaders?: string[];
+        matchBody?: boolean;
+        matchQuery?: boolean;
+        caseSensitive?: boolean;
+        shouldRecord?: (requestOpts: any) => boolean;
+        shouldPlayback?: (requestOpts: any) => boolean;
+        excludeUrls?: (string | RegExp)[];
+    }
+    export interface Snapshot {
+        request: {
+            method: string;
+            url: string;
+            headers: Record<string, string>;
+            body?: string;
+        };
+        responses: {
+            statusCode: number;
+            headers: Record<string, string>;
+            body: string;
+            trailers: Record<string, string>;
+        }[];
+        callCount: number;
+        timestamp: string;
+    }
+    export interface SnapshotInfo {
+        hash: string;
+        request: {
+            method: string;
+            url: string;
+            headers: Record<string, string>;
+            body?: string;
+        };
+        responseCount: number;
+        callCount: number;
+        timestamp: string;
+    }
+    export interface SnapshotData {
+        hash: string;
+        snapshot: Snapshot;
+    }
+}
+declare class SnapshotAgent extends MockAgent {
+    constructor(options?: SnapshotAgent.Options);
+    saveSnapshots(filePath?: string): Promise<void>;
+    loadSnapshots(filePath?: string): Promise<void>;
+    getRecorder(): SnapshotRecorder;
+    getMode(): SnapshotRecorder.SnapshotRecorderMode;
+    clearSnapshots(): void;
+    resetCallCounts(): void;
+    deleteSnapshot(requestOpts: any): boolean;
+    getSnapshotInfo(requestOpts: any): SnapshotRecorder.SnapshotInfo | null;
+    replaceSnapshots(snapshotData: SnapshotRecorder.SnapshotData[]): void;
+}
+declare namespace SnapshotAgent {
+    export interface Options extends MockAgent.Options {
+        mode?: SnapshotRecorder.SnapshotRecorderMode;
+        snapshotPath?: string;
+        maxSnapshots?: number;
+        autoFlush?: boolean;
+        flushInterval?: number;
+        matchHeaders?: string[];
+        ignoreHeaders?: string[];
+        excludeHeaders?: string[];
+        matchBody?: boolean;
+        matchQuery?: boolean;
+        caseSensitive?: boolean;
+        shouldRecord?: (requestOpts: any) => boolean;
+        shouldPlayback?: (requestOpts: any) => boolean;
+        excludeUrls?: (string | RegExp)[];
+    }
+}
+export { SnapshotAgent, SnapshotRecorder };

package/types/undici/socks5-proxy-agent.d.ts

@@ -0,0 +1,17 @@
+import Dispatcher from './dispatcher';
+import buildConnector from './connector';
+import { IncomingHttpHeaders } from './header';
+import Pool from './pool';
+export default Socks5ProxyAgent;
+declare class Socks5ProxyAgent extends Dispatcher {
+    constructor(proxyUrl: string | URL, options?: Socks5ProxyAgent.Options);
+}
+declare namespace Socks5ProxyAgent {
+    export interface Options extends Pool.Options {
+        headers?: IncomingHttpHeaders;
+        username?: string;
+        password?: string;
+        connect?: buildConnector.connector;
+        proxyTls?: buildConnector.BuildOptions;
+    }
+}

package/types/undici/util.d.ts

@@ -0,0 +1,4 @@
+export namespace util {
+    export function headerNameToString(value: string | Buffer): string;
+    export function parseHeaders(headers: (Buffer | string | (Buffer | string)[])[], obj?: Record<string, string | string[]>): Record<string, string | string[]>;
+}

package/types/undici/utility.d.ts

@@ -0,0 +1,2 @@
+type AutocompletePrimitiveBaseType<T> = T extends string ? string : T extends number ? number : T extends boolean ? boolean : never;
+export type Autocomplete<T> = T | (AutocompletePrimitiveBaseType<T> & Record<never, never>);

package/types/undici/webidl.d.ts

@@ -0,0 +1,121 @@
+import { BufferSource } from 'node:stream/web';
+import * as undici from './index';
+type Converter<T> = (object: unknown) => T;
+type SequenceConverter<T> = (object: unknown, iterable?: IterableIterator<T>) => T[];
+type RecordConverter<K extends string, V> = (object: unknown) => Record<K, V>;
+interface WebidlErrors {
+    exception(opts: {
+        header: string;
+        message: string;
+    }): TypeError;
+    conversionFailed(opts: {
+        prefix: string;
+        argument: string;
+        types: string[];
+    }): TypeError;
+    invalidArgument(opts: {
+        prefix: string;
+        value: string;
+        type: string;
+    }): TypeError;
+}
+interface WebIDLTypes {
+    UNDEFINED: 1;
+    BOOLEAN: 2;
+    STRING: 3;
+    SYMBOL: 4;
+    NUMBER: 5;
+    BIGINT: 6;
+    NULL: 7;
+    OBJECT: 8;
+}
+interface WebidlUtil {
+    Type(object: unknown): WebIDLTypes[keyof WebIDLTypes];
+    TypeValueToString(o: unknown): 'Undefined' | 'Boolean' | 'String' | 'Symbol' | 'Number' | 'BigInt' | 'Null' | 'Object';
+    Types: WebIDLTypes;
+    ConvertToInt(V: unknown, bitLength: number, signedness: 'signed' | 'unsigned', flags?: number): number;
+    IntegerPart(N: number): number;
+    Stringify(V: any): string;
+    MakeTypeAssertion<I>(I: I): (arg: any) => arg is I;
+    markAsUncloneable(V: any): void;
+    IsResizableArrayBuffer(V: ArrayBufferLike): boolean;
+    HasFlag(flag: number, attributes: number): boolean;
+    getCopyOfBytesHeldByBufferSource(bufferSource: BufferSource): Uint8Array;
+}
+interface WebidlConverters {
+    DOMString(V: unknown, prefix: string, argument: string, flags?: number): string;
+    ByteString(V: unknown, prefix: string, argument: string): string;
+    USVString(V: unknown): string;
+    boolean(V: unknown): boolean;
+    any<Value>(V: Value): Value;
+    ['long long'](V: unknown): number;
+    ['unsigned long long'](V: unknown): number;
+    ['unsigned long'](V: unknown): number;
+    ['unsigned short'](V: unknown, flags?: number): number;
+    ArrayBuffer(V: unknown, prefix: string, argument: string, options?: {
+        allowResizable: boolean;
+    }): ArrayBuffer;
+    SharedArrayBuffer(V: unknown, prefix: string, argument: string, options?: {
+        allowResizable: boolean;
+    }): SharedArrayBuffer;
+    TypedArray(V: unknown, T: new () => NodeJS.TypedArray, prefix: string, argument: string, flags?: number): NodeJS.TypedArray;
+    DataView(V: unknown, prefix: string, argument: string, flags?: number): DataView;
+    ArrayBufferView(V: unknown, prefix: string, argument: string, flags?: number): NodeJS.ArrayBufferView;
+    BufferSource(V: unknown, prefix: string, argument: string, flags?: number): ArrayBuffer | NodeJS.ArrayBufferView;
+    AllowSharedBufferSource(V: unknown, prefix: string, argument: string, flags?: number): ArrayBuffer | SharedArrayBuffer | NodeJS.ArrayBufferView;
+    ['sequence<ByteString>']: SequenceConverter<string>;
+    ['sequence<sequence<ByteString>>']: SequenceConverter<string[]>;
+    ['record<ByteString, ByteString>']: RecordConverter<string, string>;
+    RequestInfo(V: unknown): undici.Request | string;
+    RequestInit(V: unknown): undici.RequestInit;
+    EventHandlerNonNull(V: unknown): Function | null;
+    WebSocketStreamWrite(V: unknown): ArrayBuffer | NodeJS.TypedArray | string;
+    [Key: string]: (...args: any[]) => unknown;
+}
+type WebidlIsFunction<T> = (arg: any) => arg is T;
+interface WebidlIs {
+    Request: WebidlIsFunction<undici.Request>;
+    Response: WebidlIsFunction<undici.Response>;
+    ReadableStream: WebidlIsFunction<ReadableStream>;
+    Blob: WebidlIsFunction<Blob>;
+    URLSearchParams: WebidlIsFunction<URLSearchParams>;
+    File: WebidlIsFunction<File>;
+    FormData: WebidlIsFunction<undici.FormData>;
+    URL: WebidlIsFunction<URL>;
+    WebSocketError: WebidlIsFunction<undici.WebSocketError>;
+    AbortSignal: WebidlIsFunction<AbortSignal>;
+    MessagePort: WebidlIsFunction<MessagePort>;
+    USVString: WebidlIsFunction<string>;
+    BufferSource: WebidlIsFunction<ArrayBuffer | NodeJS.TypedArray>;
+}
+export interface Webidl {
+    errors: WebidlErrors;
+    util: WebidlUtil;
+    converters: WebidlConverters;
+    is: WebidlIs;
+    attributes: WebIDLExtendedAttributes;
+    brandCheck<Interface extends new () => unknown>(V: unknown, cls: Interface): asserts V is Interface;
+    brandCheckMultiple<Interfaces extends (new () => unknown)[]>(list: Interfaces): (V: any) => asserts V is Interfaces[number];
+    sequenceConverter<Type>(C: Converter<Type>): SequenceConverter<Type>;
+    illegalConstructor(): never;
+    recordConverter<K extends string, V>(keyConverter: Converter<K>, valueConverter: Converter<V>): RecordConverter<K, V>;
+    interfaceConverter<Interface>(typeCheck: WebidlIsFunction<Interface>, name: string): (V: unknown, prefix: string, argument: string) => asserts V is Interface;
+    dictionaryConverter(converters: {
+        key: string;
+        defaultValue?: () => unknown;
+        required?: boolean;
+        converter: (...args: unknown[]) => unknown;
+        allowedValues?: unknown[];
+    }[]): (V: unknown) => Record<string, unknown>;
+    nullableConverter<T>(converter: Converter<T>): (V: unknown) => ReturnType<typeof converter> | null;
+    argumentLengthCheck(args: {
+        length: number;
+    }, min: number, context: string): void;
+}
+interface WebIDLExtendedAttributes {
+    Clamp: number;
+    EnforceRange: number;
+    AllowShared: number;
+    AllowResizable: number;
+    LegacyNullToEmptyString: number;
+}

package/types/undici/websocket.d.ts

@@ -0,0 +1,130 @@
+/// <reference path="../node/index.d.ts" />
+import type { Blob } from 'node:buffer';
+import type { ReadableStream, WritableStream } from 'node:stream/web';
+import type { MessagePort } from 'node:worker_threads';
+import { EventInit, EventListenerOptions, AddEventListenerOptions, EventListenerOrEventListenerObject } from './patch';
+import Dispatcher from './dispatcher';
+import { HeadersInit } from './fetch';
+export type BinaryType = 'blob' | 'arraybuffer';
+interface WebSocketEventMap {
+    close: CloseEvent;
+    error: ErrorEvent;
+    message: MessageEvent;
+    open: Event;
+}
+interface WebSocket extends EventTarget {
+    binaryType: BinaryType;
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    onclose: ((this: WebSocket, ev: WebSocketEventMap['close']) => any) | null;
+    onerror: ((this: WebSocket, ev: WebSocketEventMap['error']) => any) | null;
+    onmessage: ((this: WebSocket, ev: WebSocketEventMap['message']) => any) | null;
+    onopen: ((this: WebSocket, ev: WebSocketEventMap['open']) => any) | null;
+    readonly protocol: string;
+    readonly readyState: number;
+    readonly url: string;
+    close(code?: number, reason?: string): void;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+    addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+export declare const WebSocket: {
+    prototype: WebSocket;
+    new (url: string | URL, protocols?: string | string[] | WebSocketInit): WebSocket;
+    readonly CLOSED: number;
+    readonly CLOSING: number;
+    readonly CONNECTING: number;
+    readonly OPEN: number;
+};
+interface CloseEventInit extends EventInit {
+    code?: number;
+    reason?: string;
+    wasClean?: boolean;
+}
+interface CloseEvent extends Event {
+    readonly code: number;
+    readonly reason: string;
+    readonly wasClean: boolean;
+}
+export declare const CloseEvent: {
+    prototype: CloseEvent;
+    new (type: string, eventInitDict?: CloseEventInit): CloseEvent;
+};
+interface MessageEventInit<T = any> extends EventInit {
+    data?: T;
+    lastEventId?: string;
+    origin?: string;
+    ports?: MessagePort[];
+    source?: MessagePort | null;
+}
+interface MessageEvent<T = any> extends Event {
+    readonly data: T;
+    readonly lastEventId: string;
+    readonly origin: string;
+    readonly ports: readonly MessagePort[];
+    readonly source: MessagePort | null;
+    initMessageEvent(type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessagePort | null, ports?: MessagePort[]): void;
+}
+export declare const MessageEvent: {
+    prototype: MessageEvent;
+    new <T>(type: string, eventInitDict?: MessageEventInit<T>): MessageEvent<T>;
+};
+interface ErrorEventInit extends EventInit {
+    message?: string;
+    filename?: string;
+    lineno?: number;
+    colno?: number;
+    error?: any;
+}
+interface ErrorEvent extends Event {
+    readonly message: string;
+    readonly filename: string;
+    readonly lineno: number;
+    readonly colno: number;
+    readonly error: Error;
+}
+export declare const ErrorEvent: {
+    prototype: ErrorEvent;
+    new (type: string, eventInitDict?: ErrorEventInit): ErrorEvent;
+};
+interface WebSocketInit {
+    protocols?: string | string[];
+    dispatcher?: Dispatcher;
+    headers?: HeadersInit;
+}
+interface WebSocketStreamOptions {
+    protocols?: string | string[];
+    signal?: AbortSignal;
+}
+interface WebSocketCloseInfo {
+    closeCode: number;
+    reason: string;
+}
+interface WebSocketStream {
+    closed: Promise<WebSocketCloseInfo>;
+    opened: Promise<{
+        extensions: string;
+        protocol: string;
+        readable: ReadableStream;
+        writable: WritableStream;
+    }>;
+    url: string;
+    close(options?: Partial<WebSocketCloseInfo>): void;
+}
+export declare const WebSocketStream: {
+    prototype: WebSocketStream;
+    new (url: string | URL, options?: WebSocketStreamOptions): WebSocketStream;
+};
+interface WebSocketError extends Event, WebSocketCloseInfo {
+}
+export declare const WebSocketError: {
+    prototype: WebSocketError;
+    new (type: string, init?: WebSocketCloseInfo): WebSocketError;
+};
+export declare const ping: (ws: WebSocket, body?: Buffer) => void;

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.