@runlith/tagma 0.0.0-stage → 0.2.3

package/types/node/process.d.ts

@@ -0,0 +1,436 @@
+declare module "node:process" {
+    import { Control, MessageOptions, SendHandle } from "node:child_process";
+    import { PathLike } from "node:fs";
+    import * as tty from "node:tty";
+    import { Worker } from "node:worker_threads";
+    interface BuiltInModule {
+        "assert": typeof import("assert");
+        "node:assert": typeof import("node:assert");
+        "assert/strict": typeof import("assert/strict");
+        "node:assert/strict": typeof import("node:assert/strict");
+        "async_hooks": typeof import("async_hooks");
+        "node:async_hooks": typeof import("node:async_hooks");
+        "buffer": typeof import("buffer");
+        "node:buffer": typeof import("node:buffer");
+        "child_process": typeof import("child_process");
+        "node:child_process": typeof import("node:child_process");
+        "cluster": typeof import("cluster");
+        "node:cluster": typeof import("node:cluster");
+        "console": typeof import("console");
+        "node:console": typeof import("node:console");
+        "constants": typeof import("constants");
+        "node:constants": typeof import("node:constants");
+        "crypto": typeof import("crypto");
+        "node:crypto": typeof import("node:crypto");
+        "dgram": typeof import("dgram");
+        "node:dgram": typeof import("node:dgram");
+        "diagnostics_channel": typeof import("diagnostics_channel");
+        "node:diagnostics_channel": typeof import("node:diagnostics_channel");
+        "dns": typeof import("dns");
+        "node:dns": typeof import("node:dns");
+        "dns/promises": typeof import("dns/promises");
+        "node:dns/promises": typeof import("node:dns/promises");
+        "domain": typeof import("domain");
+        "node:domain": typeof import("node:domain");
+        "events": typeof import("events");
+        "node:events": typeof import("node:events");
+        "fs": typeof import("fs");
+        "node:fs": typeof import("node:fs");
+        "fs/promises": typeof import("fs/promises");
+        "node:fs/promises": typeof import("node:fs/promises");
+        "http": typeof import("http");
+        "node:http": typeof import("node:http");
+        "http2": typeof import("http2");
+        "node:http2": typeof import("node:http2");
+        "https": typeof import("https");
+        "node:https": typeof import("node:https");
+        "inspector": typeof import("inspector");
+        "node:inspector": typeof import("node:inspector");
+        "inspector/promises": typeof import("inspector/promises");
+        "node:inspector/promises": typeof import("node:inspector/promises");
+        "module": typeof import("module");
+        "node:module": typeof import("node:module");
+        "net": typeof import("net");
+        "node:net": typeof import("node:net");
+        "os": typeof import("os");
+        "node:os": typeof import("node:os");
+        "path": typeof import("path");
+        "node:path": typeof import("node:path");
+        "path/posix": typeof import("path/posix");
+        "node:path/posix": typeof import("node:path/posix");
+        "path/win32": typeof import("path/win32");
+        "node:path/win32": typeof import("node:path/win32");
+        "perf_hooks": typeof import("perf_hooks");
+        "node:perf_hooks": typeof import("node:perf_hooks");
+        "process": typeof import("process");
+        "node:process": typeof import("node:process");
+        "punycode": typeof import("punycode");
+        "node:punycode": typeof import("node:punycode");
+        "querystring": typeof import("querystring");
+        "node:querystring": typeof import("node:querystring");
+        "node:quic": typeof import("node:quic");
+        "readline": typeof import("readline");
+        "node:readline": typeof import("node:readline");
+        "readline/promises": typeof import("readline/promises");
+        "node:readline/promises": typeof import("node:readline/promises");
+        "repl": typeof import("repl");
+        "node:repl": typeof import("node:repl");
+        "node:sea": typeof import("node:sea");
+        "node:sqlite": typeof import("node:sqlite");
+        "stream": typeof import("stream");
+        "node:stream": typeof import("node:stream");
+        "stream/consumers": typeof import("stream/consumers");
+        "node:stream/consumers": typeof import("node:stream/consumers");
+        "stream/iter": typeof import("stream/iter");
+        "node:stream/iter": typeof import("node:stream/iter");
+        "stream/promises": typeof import("stream/promises");
+        "node:stream/promises": typeof import("node:stream/promises");
+        "stream/web": typeof import("stream/web");
+        "node:stream/web": typeof import("node:stream/web");
+        "string_decoder": typeof import("string_decoder");
+        "node:string_decoder": typeof import("node:string_decoder");
+        "node:test": typeof import("node:test");
+        "node:test/reporters": typeof import("node:test/reporters");
+        "timers": typeof import("timers");
+        "node:timers": typeof import("node:timers");
+        "timers/promises": typeof import("timers/promises");
+        "node:timers/promises": typeof import("node:timers/promises");
+        "tls": typeof import("tls");
+        "node:tls": typeof import("node:tls");
+        "trace_events": typeof import("trace_events");
+        "node:trace_events": typeof import("node:trace_events");
+        "tty": typeof import("tty");
+        "node:tty": typeof import("node:tty");
+        "url": typeof import("url");
+        "node:url": typeof import("node:url");
+        "util": typeof import("util");
+        "node:util": typeof import("node:util");
+        "util/types": typeof import("util/types");
+        "node:util/types": typeof import("node:util/types");
+        "v8": typeof import("v8");
+        "node:v8": typeof import("node:v8");
+        "vm": typeof import("vm");
+        "node:vm": typeof import("node:vm");
+        "wasi": typeof import("wasi");
+        "node:wasi": typeof import("node:wasi");
+        "worker_threads": typeof import("worker_threads");
+        "node:worker_threads": typeof import("node:worker_threads");
+        "zlib": typeof import("zlib");
+        "node:zlib": typeof import("node:zlib");
+    }
+    type SignalsEventMap = {
+        [S in NodeJS.Signals]: [
+            signal: S
+        ];
+    };
+    interface ProcessEventMap extends SignalsEventMap {
+        "beforeExit": [
+            code: number
+        ];
+        "disconnect": [
+        ];
+        "exit": [
+            code: number
+        ];
+        "message": [
+            message: object | boolean | number | string | null,
+            sendHandle: SendHandle | undefined
+        ];
+        "rejectionHandled": [
+            promise: Promise<unknown>
+        ];
+        "uncaughtException": [
+            error: Error,
+            origin: NodeJS.UncaughtExceptionOrigin
+        ];
+        "uncaughtExceptionMonitor": [
+            error: Error,
+            origin: NodeJS.UncaughtExceptionOrigin
+        ];
+        "unhandledRejection": [
+            reason: unknown,
+            promise: Promise<unknown>
+        ];
+        "warning": [
+            warning: Error
+        ];
+        "worker": [
+            worker: Worker
+        ];
+        "workerMessage": [
+            value: any,
+            source: number
+        ];
+    }
+    global {
+        var process: NodeJS.Process;
+        namespace process {
+            export { ProcessEventMap };
+        }
+        namespace NodeJS {
+            interface ReadStream extends tty.ReadStream {
+            }
+            interface WriteStream extends tty.WriteStream {
+            }
+            interface MemoryUsageFn {
+                (): MemoryUsage;
+                rss(): number;
+            }
+            interface MemoryUsage {
+                rss: number;
+                heapTotal: number;
+                heapUsed: number;
+                external: number;
+                arrayBuffers: number;
+            }
+            interface CpuUsage {
+                user: number;
+                system: number;
+            }
+            interface ProcessRelease {
+                name: string;
+                sourceUrl?: string | undefined;
+                headersUrl?: string | undefined;
+                libUrl?: string | undefined;
+                lts?: string | undefined;
+            }
+            interface ProcessFeatures {
+                readonly cached_builtins: boolean;
+                readonly debug: boolean;
+                readonly inspector: boolean;
+                readonly ipv6: boolean;
+                readonly require_module: boolean;
+                readonly tls: boolean;
+                readonly tls_alpn: boolean;
+                readonly tls_ocsp: boolean;
+                readonly tls_sni: boolean;
+                readonly typescript: "strip" | "transform" | false;
+                readonly uv: boolean;
+            }
+            interface ProcessVersions extends Dict<string> {
+                http_parser: string;
+                node: string;
+                v8: string;
+                ares: string;
+                uv: string;
+                zlib: string;
+                modules: string;
+                openssl: string;
+            }
+            type Platform = "aix" | "android" | "darwin" | "freebsd" | "haiku" | "linux" | "openbsd" | "sunos" | "win32" | "cygwin" | "netbsd";
+            type Architecture = "arm" | "arm64" | "ia32" | "loong64" | "mips" | "mipsel" | "ppc64" | "riscv64" | "s390x" | "x64";
+            type Signals = "SIGABRT" | "SIGALRM" | "SIGBUS" | "SIGCHLD" | "SIGCONT" | "SIGFPE" | "SIGHUP" | "SIGILL" | "SIGINT" | "SIGIO" | "SIGIOT" | "SIGKILL" | "SIGPIPE" | "SIGPOLL" | "SIGPROF" | "SIGPWR" | "SIGQUIT" | "SIGSEGV" | "SIGSTKFLT" | "SIGSTOP" | "SIGSYS" | "SIGTERM" | "SIGTRAP" | "SIGTSTP" | "SIGTTIN" | "SIGTTOU" | "SIGUNUSED" | "SIGURG" | "SIGUSR1" | "SIGUSR2" | "SIGVTALRM" | "SIGWINCH" | "SIGXCPU" | "SIGXFSZ" | "SIGBREAK" | "SIGLOST" | "SIGINFO";
+            type UncaughtExceptionOrigin = "uncaughtException" | "unhandledRejection";
+            type BeforeExitListener = (...args: ProcessEventMap["beforeExit"]) => void;
+            type DisconnectListener = (...args: ProcessEventMap["disconnect"]) => void;
+            type ExitListener = (...args: ProcessEventMap["exit"]) => void;
+            type MessageListener = (...args: ProcessEventMap["message"]) => void;
+            type RejectionHandledListener = (...args: ProcessEventMap["rejectionHandled"]) => void;
+            type SignalsListener = (signal: Signals) => void;
+            type UncaughtExceptionListener = (...args: ProcessEventMap["uncaughtException"]) => void;
+            type UnhandledRejectionListener = (...args: ProcessEventMap["unhandledRejection"]) => void;
+            type WarningListener = (...args: ProcessEventMap["warning"]) => void;
+            type WorkerListener = (...args: ProcessEventMap["worker"]) => void;
+            interface Socket extends ReadWriteStream {
+                isTTY?: true | undefined;
+            }
+            interface ProcessEnv extends Dict<string> {
+            }
+            interface HRTime {
+                (time?: [
+                    number,
+                    number
+                ]): [
+                    number,
+                    number
+                ];
+                bigint(): bigint;
+            }
+            interface ProcessPermission {
+                has(scope: string, reference?: string): boolean;
+            }
+            interface ProcessReport {
+                compact: boolean;
+                directory: string;
+                filename: string;
+                getReport(err?: Error): object;
+                reportOnFatalError: boolean;
+                reportOnSignal: boolean;
+                reportOnUncaughtException: boolean;
+                excludeEnv: boolean;
+                signal: Signals;
+                writeReport(fileName?: string, err?: Error): string;
+                writeReport(err?: Error): string;
+            }
+            interface ResourceUsage {
+                fsRead: number;
+                fsWrite: number;
+                involuntaryContextSwitches: number;
+                ipcReceived: number;
+                ipcSent: number;
+                majorPageFault: number;
+                maxRSS: number;
+                minorPageFault: number;
+                sharedMemorySize: number;
+                signalsCount: number;
+                swappedOut: number;
+                systemCPUTime: number;
+                unsharedDataSize: number;
+                unsharedStackSize: number;
+                userCPUTime: number;
+                voluntaryContextSwitches: number;
+            }
+            interface EmitWarningOptions {
+                type?: string | undefined;
+                code?: string | undefined;
+                ctor?: Function | undefined;
+                detail?: string | undefined;
+            }
+            interface ProcessConfig {
+                readonly target_defaults: {
+                    readonly cflags: any[];
+                    readonly default_configuration: string;
+                    readonly defines: string[];
+                    readonly include_dirs: string[];
+                    readonly libraries: string[];
+                };
+                readonly variables: {
+                    readonly clang: number;
+                    readonly host_arch: string;
+                    readonly node_install_npm: boolean;
+                    readonly node_install_waf: boolean;
+                    readonly node_prefix: string;
+                    readonly node_shared_openssl: boolean;
+                    readonly node_shared_v8: boolean;
+                    readonly node_shared_zlib: boolean;
+                    readonly node_use_dtrace: boolean;
+                    readonly node_use_etw: boolean;
+                    readonly node_use_openssl: boolean;
+                    readonly target_arch: string;
+                    readonly v8_no_strict_aliasing: number;
+                    readonly v8_use_snapshot: boolean;
+                    readonly visibility: string;
+                };
+            }
+            interface Process extends EventEmitter {
+                stdout: WriteStream & {
+                    fd: 1;
+                };
+                stderr: WriteStream & {
+                    fd: 2;
+                };
+                stdin: ReadStream & {
+                    fd: 0;
+                };
+                argv: string[];
+                argv0: string;
+                execArgv: string[];
+                execPath: string;
+                abort(): never;
+                addUncaughtExceptionCaptureCallback(fn: (err: unknown) => boolean): void;
+                chdir(directory: string): void;
+                cwd(): string;
+                debugPort: number;
+                dlopen(module: object, filename: string, flags?: number): void;
+                emitWarning(warning: string | Error, ctor?: Function): void;
+                emitWarning(warning: string | Error, type?: string, ctor?: Function): void;
+                emitWarning(warning: string | Error, type?: string, code?: string, ctor?: Function): void;
+                emitWarning(warning: string | Error, options?: EmitWarningOptions): void;
+                env: ProcessEnv;
+                exit(code?: number | string | null): never;
+                exitCode: number | string | null | undefined;
+                finalization: {
+                    register<T extends object>(ref: T, callback: (ref: T, event: "exit") => void): void;
+                    registerBeforeExit<T extends object>(ref: T, callback: (ref: T, event: "beforeExit") => void): void;
+                    unregister(ref: object): void;
+                };
+                getActiveResourcesInfo(): string[];
+                getBuiltinModule<ID extends keyof BuiltInModule>(id: ID): BuiltInModule[ID];
+                getBuiltinModule(id: string): object | undefined;
+                getgid?: () => number;
+                setgid?: (id: number | string) => void;
+                getuid?: () => number;
+                setuid?: (id: number | string) => void;
+                geteuid?: () => number;
+                seteuid?: (id: number | string) => void;
+                getegid?: () => number;
+                setegid?: (id: number | string) => void;
+                getgroups?: () => number[];
+                setgroups?: (groups: ReadonlyArray<string | number>) => void;
+                setUncaughtExceptionCaptureCallback(cb: ((err: Error) => void) | null): void;
+                hasUncaughtExceptionCaptureCallback(): boolean;
+                readonly sourceMapsEnabled: boolean;
+                setSourceMapsEnabled(value: boolean): void;
+                readonly version: string;
+                readonly versions: ProcessVersions;
+                readonly config: ProcessConfig;
+                kill(pid: number, signal?: string | number): true;
+                loadEnvFile(path?: PathLike): void;
+                readonly pid: number;
+                readonly ppid: number;
+                threadCpuUsage(previousValue?: CpuUsage): CpuUsage;
+                title: string;
+                readonly arch: Architecture;
+                readonly platform: Platform;
+                mainModule?: Module;
+                memoryUsage: MemoryUsageFn;
+                constrainedMemory(): number;
+                availableMemory(): number;
+                cpuUsage(previousValue?: CpuUsage): CpuUsage;
+                nextTick(callback: Function, ...args: any[]): void;
+                noDeprecation?: boolean;
+                permission: ProcessPermission;
+                readonly release: ProcessRelease;
+                readonly features: ProcessFeatures;
+                traceProcessWarnings: boolean;
+                umask(): number;
+                umask(mask: string | number): number;
+                uptime(): number;
+                hrtime: HRTime;
+                channel?: Control;
+                send?(message: any, sendHandle?: SendHandle, options?: MessageOptions, callback?: (error: Error | null) => void): boolean;
+                send?(message: any, sendHandle: SendHandle, callback?: (error: Error | null) => void): boolean;
+                send?(message: any, callback: (error: Error | null) => void): boolean;
+                disconnect?(): void;
+                connected: boolean;
+                allowedNodeEnvironmentFlags: ReadonlySet<string>;
+                report: ProcessReport;
+                resourceUsage(): ResourceUsage;
+                throwDeprecation: boolean;
+                traceDeprecation: boolean;
+                ref(maybeRefable: any): void;
+                unref(maybeRefable: any): void;
+                execve?(file: string, args?: readonly string[], env?: ProcessEnv): never;
+                addListener<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                emit<E extends keyof ProcessEventMap>(eventName: E, ...args: ProcessEventMap[E]): boolean;
+                emit(eventName: string | symbol, ...args: any[]): boolean;
+                listenerCount<E extends keyof ProcessEventMap>(eventName: E, listener?: (...args: ProcessEventMap[E]) => void): number;
+                listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+                listeners<E extends keyof ProcessEventMap>(eventName: E): ((...args: ProcessEventMap[E]) => void)[];
+                listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+                off<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                on<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                once<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                prependListener<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                prependOnceListener<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                rawListeners<E extends keyof ProcessEventMap>(eventName: E): ((...args: ProcessEventMap[E]) => void)[];
+                rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+                removeAllListeners<E extends keyof ProcessEventMap>(eventName?: E): this;
+                removeAllListeners(eventName?: string | symbol): this;
+                removeListener<E extends keyof ProcessEventMap>(eventName: E, listener: (...args: ProcessEventMap[E]) => void): this;
+                removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+            }
+        }
+    }
+    export = process;
+}
+declare module "process" {
+    import process = require("node:process");
+    export = process;
+}

package/types/node/punycode.d.ts

@@ -0,0 +1,15 @@
+declare module "node:punycode" {
+    function decode(string: string): string;
+    function encode(string: string): string;
+    function toUnicode(domain: string): string;
+    function toASCII(domain: string): string;
+    const ucs2: ucs2;
+    interface ucs2 {
+        decode(string: string): number[];
+        encode(codePoints: readonly number[]): string;
+    }
+    const version: string;
+}
+declare module "punycode" {
+    export * from "node:punycode";
+}

package/types/node/querystring.d.ts

@@ -0,0 +1,22 @@
+declare module "node:querystring" {
+    interface StringifyOptions {
+        encodeURIComponent?: ((str: string) => string) | undefined;
+    }
+    interface ParseOptions {
+        maxKeys?: number | undefined;
+        decodeURIComponent?: ((str: string) => string) | undefined;
+    }
+    interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> {
+    }
+    interface ParsedUrlQueryInput extends NodeJS.Dict<string | number | boolean | bigint | ReadonlyArray<string | number | boolean | bigint> | null> {
+    }
+    function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
+    function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
+    const encode: typeof stringify;
+    const decode: typeof parse;
+    function escape(str: string): string;
+    function unescape(str: string): string;
+}
+declare module "querystring" {
+    export * from "node:querystring";
+}

package/types/node/quic.d.ts

@@ -0,0 +1,203 @@
+declare module "node:quic" {
+    import { KeyObject, webcrypto } from "node:crypto";
+    import { SocketAddress } from "node:net";
+    import { ReadableStream } from "node:stream/web";
+    type OnSessionCallback = (this: QuicEndpoint, session: QuicSession) => void;
+    type OnStreamCallback = (this: QuicSession, stream: QuicStream) => void;
+    type OnDatagramCallback = (this: QuicSession, datagram: Uint8Array, early: boolean) => void;
+    type OnDatagramStatusCallback = (this: QuicSession, id: bigint, status: "lost" | "acknowledged") => void;
+    type OnPathValidationCallback = (this: QuicSession, result: "success" | "failure" | "aborted", newLocalAddress: SocketAddress, newRemoteAddress: SocketAddress, oldLocalAddress: SocketAddress, oldRemoteAddress: SocketAddress, preferredAddress: boolean) => void;
+    type OnSessionTicketCallback = (this: QuicSession, ticket: object) => void;
+    type OnVersionNegotiationCallback = (this: QuicSession, version: number, requestedVersions: number[], supportedVersions: number[]) => void;
+    type OnHandshakeCallback = (this: QuicSession, sni: string, alpn: string, cipher: string, cipherVersion: string, validationErrorReason: string, validationErrorCode: number, earlyDataAccepted: boolean) => void;
+    type OnBlockedCallback = (this: QuicStream) => void;
+    type OnStreamErrorCallback = (this: QuicStream, error: any) => void;
+    interface TransportParams {
+        preferredAddressIpv4?: SocketAddress | undefined;
+        preferredAddressIpv6?: SocketAddress | undefined;
+        initialMaxStreamDataBidiLocal?: bigint | number | undefined;
+        initialMaxStreamDataBidiRemote?: bigint | number | undefined;
+        initialMaxStreamDataUni?: bigint | number | undefined;
+        initialMaxData?: bigint | number | undefined;
+        initialMaxStreamsBidi?: bigint | number | undefined;
+        initialMaxStreamsUni?: bigint | number | undefined;
+        maxIdleTimeout?: bigint | number | undefined;
+        activeConnectionIDLimit?: bigint | number | undefined;
+        ackDelayExponent?: bigint | number | undefined;
+        maxAckDelay?: bigint | number | undefined;
+        maxDatagramFrameSize?: bigint | number | undefined;
+    }
+    interface SessionOptions {
+        endpoint?: EndpointOptions | QuicEndpoint | undefined;
+        alpn?: string | undefined;
+        ca?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
+        cc?: `${constants.cc}` | undefined;
+        certs?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
+        ciphers?: string | undefined;
+        crl?: ArrayBuffer | NodeJS.ArrayBufferView | ReadonlyArray<ArrayBuffer | NodeJS.ArrayBufferView> | undefined;
+        groups?: string | undefined;
+        keylog?: boolean | undefined;
+        keys?: KeyObject | readonly KeyObject[] | undefined;
+        maxPayloadSize?: bigint | number | undefined;
+        maxStreamWindow?: bigint | number | undefined;
+        maxWindow?: bigint | number | undefined;
+        minVersion?: number | undefined;
+        preferredAddressPolicy?: "use" | "ignore" | "default" | undefined;
+        qlog?: boolean | undefined;
+        sessionTicket?: NodeJS.ArrayBufferView | undefined;
+        handshakeTimeout?: bigint | number | undefined;
+        sni?: string | undefined;
+        tlsTrace?: boolean | undefined;
+        transportParams?: TransportParams | undefined;
+        unacknowledgedPacketThreshold?: bigint | number | undefined;
+        verifyClient?: boolean | undefined;
+        verifyPrivateKey?: boolean | undefined;
+        version?: number | undefined;
+    }
+    function connect(address: string | SocketAddress, options?: SessionOptions): Promise<QuicSession>;
+    function listen(onsession: OnSessionCallback, options?: SessionOptions): Promise<QuicEndpoint>;
+    interface EndpointOptions {
+        address?: SocketAddress | string | undefined;
+        addressLRUSize?: bigint | number | undefined;
+        ipv6Only?: boolean | undefined;
+        maxConnectionsPerHost?: bigint | number | undefined;
+        maxConnectionsTotal?: bigint | number | undefined;
+        maxRetries?: bigint | number | undefined;
+        maxStatelessResetsPerHost?: bigint | number | undefined;
+        retryTokenExpiration?: bigint | number | undefined;
+        resetTokenSecret?: NodeJS.ArrayBufferView | undefined;
+        tokenExpiration?: bigint | number | undefined;
+        tokenSecret?: NodeJS.ArrayBufferView | undefined;
+        udpReceiveBufferSize?: number | undefined;
+        udpSendBufferSize?: number | undefined;
+        udpTTL?: number | undefined;
+        validateAddress?: boolean | undefined;
+    }
+    class QuicEndpoint implements AsyncDisposable {
+        constructor(options?: EndpointOptions);
+        readonly address: SocketAddress | undefined;
+        busy: boolean;
+        close(): Promise<void>;
+        readonly closed: Promise<void>;
+        readonly closing: boolean;
+        destroy(error?: any): void;
+        readonly destroyed: boolean;
+        readonly stats: QuicEndpoint.Stats;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    namespace QuicEndpoint {
+        class Stats {
+            private constructor();
+            readonly createdAt: bigint;
+            readonly destroyedAt: bigint;
+            readonly bytesReceived: bigint;
+            readonly bytesSent: bigint;
+            readonly packetsReceived: bigint;
+            readonly packetsSent: bigint;
+            readonly serverSessions: bigint;
+            readonly clientSessions: bigint;
+            readonly serverBusyCount: bigint;
+            readonly retryCount: bigint;
+            readonly versionNegotiationCount: bigint;
+            readonly statelessResetCount: bigint;
+            readonly immediateCloseCount: bigint;
+        }
+    }
+    interface CreateStreamOptions {
+        body?: ArrayBuffer | NodeJS.ArrayBufferView | Blob | undefined;
+        sendOrder?: number | undefined;
+    }
+    interface SessionPath {
+        local: SocketAddress;
+        remote: SocketAddress;
+    }
+    class QuicSession implements AsyncDisposable {
+        private constructor();
+        close(): Promise<void>;
+        readonly closed: Promise<void>;
+        destroy(error?: any): void;
+        readonly destroyed: boolean;
+        readonly endpoint: QuicEndpoint;
+        onstream: OnStreamCallback | undefined;
+        ondatagram: OnDatagramCallback | undefined;
+        ondatagramstatus: OnDatagramStatusCallback | undefined;
+        onpathvalidation: OnPathValidationCallback | undefined;
+        onsessionticket: OnSessionTicketCallback | undefined;
+        onversionnegotiation: OnVersionNegotiationCallback | undefined;
+        onhandshake: OnHandshakeCallback | undefined;
+        createBidirectionalStream(options?: CreateStreamOptions): Promise<QuicStream>;
+        createUnidirectionalStream(options?: CreateStreamOptions): Promise<QuicStream>;
+        path: SessionPath | undefined;
+        sendDatagram(datagram: string | NodeJS.ArrayBufferView): bigint;
+        readonly stats: QuicSession.Stats;
+        updateKey(): void;
+        [Symbol.asyncDispose](): Promise<void>;
+    }
+    namespace QuicSession {
+        class Stats {
+            private constructor();
+            readonly createdAt: bigint;
+            readonly closingAt: bigint;
+            readonly handshakeCompletedAt: bigint;
+            readonly handshakeConfirmedAt: bigint;
+            readonly bytesReceived: bigint;
+            readonly bytesSent: bigint;
+            readonly bidiInStreamCount: bigint;
+            readonly bidiOutStreamCount: bigint;
+            readonly uniInStreamCount: bigint;
+            readonly uniOutStreamCount: bigint;
+            readonly maxBytesInFlights: bigint;
+            readonly bytesInFlight: bigint;
+            readonly blockCount: bigint;
+            readonly cwnd: bigint;
+            readonly latestRtt: bigint;
+            readonly minRtt: bigint;
+            readonly rttVar: bigint;
+            readonly smoothedRtt: bigint;
+            readonly ssthresh: bigint;
+            readonly datagramsReceived: bigint;
+            readonly datagramsSent: bigint;
+            readonly datagramsAcknowledged: bigint;
+            readonly datagramsLost: bigint;
+        }
+    }
+    class QuicStream {
+        private constructor();
+        readonly closed: Promise<void>;
+        destroy(error?: any): void;
+        readonly destroyed: boolean;
+        readonly direction: "bidi" | "uni";
+        readonly id: bigint;
+        onblocked: OnBlockedCallback | undefined;
+        onreset: OnStreamErrorCallback | undefined;
+        readonly readable: ReadableStream<Uint8Array>;
+        readonly session: QuicSession;
+        readonly stats: QuicStream.Stats;
+    }
+    namespace QuicStream {
+        class Stats {
+            private constructor();
+            readonly ackedAt: bigint;
+            readonly bytesReceived: bigint;
+            readonly bytesSent: bigint;
+            readonly createdAt: bigint;
+            readonly destroyedAt: bigint;
+            readonly finalSize: bigint;
+            readonly isConnected: bigint;
+            readonly maxOffset: bigint;
+            readonly maxOffsetAcknowledged: bigint;
+            readonly maxOffsetReceived: bigint;
+            readonly openedAt: bigint;
+            readonly receivedAt: bigint;
+        }
+    }
+    namespace constants {
+        enum cc {
+            RENO = "reno",
+            CUBIC = "cubic",
+            BBR = "bbr"
+        }
+        const DEFAULT_CIPHERS: string;
+        const DEFAULT_GROUPS: string;
+    }
+}