@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/globals.d.ts

@@ -0,0 +1,73 @@
+declare var global: typeof globalThis;
+declare var process: NodeJS.Process;
+interface ErrorConstructor {
+    captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+    prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+    stackTraceLimit: number;
+}
+declare var gc: NodeJS.GCFunction | undefined;
+declare namespace NodeJS {
+    interface CallSite {
+        getColumnNumber(): number | null;
+        getEnclosingColumnNumber(): number | null;
+        getEnclosingLineNumber(): number | null;
+        getEvalOrigin(): string | undefined;
+        getFileName(): string | null;
+        getFunction(): Function | undefined;
+        getFunctionName(): string | null;
+        getLineNumber(): number | null;
+        getMethodName(): string | null;
+        getPosition(): number;
+        getPromiseIndex(): number | null;
+        getScriptHash(): string;
+        getScriptNameOrSourceURL(): string | null;
+        getThis(): unknown;
+        getTypeName(): string | null;
+        isAsync(): boolean;
+        isConstructor(): boolean;
+        isEval(): boolean;
+        isNative(): boolean;
+        isPromiseAll(): boolean;
+        isToplevel(): boolean;
+    }
+    interface ErrnoException extends Error {
+        errno?: number | undefined;
+        code?: string | undefined;
+        path?: string | undefined;
+        syscall?: string | undefined;
+    }
+    interface RefCounted {
+        ref(): this;
+        unref(): this;
+    }
+    interface Dict<T> {
+        [key: string]: T | undefined;
+    }
+    interface ReadOnlyDict<T> {
+        readonly [key: string]: T | undefined;
+    }
+    type PartialOptions<T> = {
+        [K in keyof T]?: T[K] | undefined;
+    };
+    interface GCFunction {
+        (minor?: boolean): void;
+        (options: NodeJS.GCOptions & {
+            execution: "async";
+        }): Promise<void>;
+        (options: NodeJS.GCOptions): void;
+    }
+    interface GCOptions {
+        execution?: "sync" | "async" | undefined;
+        flavor?: "regular" | "last-resort" | undefined;
+        type?: "major-snapshot" | "major" | "minor" | undefined;
+        filename?: string | undefined;
+    }
+    interface Iterator<T, TReturn = undefined, TNext = any> extends IteratorObject<T, TReturn, TNext> {
+        [Symbol.iterator](): NodeJS.Iterator<T, TReturn, TNext>;
+    }
+    interface AsyncIterator<T, TReturn = undefined, TNext = any> extends AsyncIteratorObject<T, TReturn, TNext> {
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<T, TReturn, TNext>;
+    }
+    type BufferSource = NonSharedArrayBufferView | ArrayBuffer;
+    type AllowSharedBufferSource = ArrayBufferView | ArrayBufferLike;
+}

package/types/node/globals.typedarray.d.ts

@@ -0,0 +1,22 @@
+export {};
+declare global {
+    namespace NodeJS {
+        type TypedArray<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<TArrayBuffer> | Uint8ClampedArray<TArrayBuffer> | Uint16Array<TArrayBuffer> | Uint32Array<TArrayBuffer> | Int8Array<TArrayBuffer> | Int16Array<TArrayBuffer> | Int32Array<TArrayBuffer> | BigUint64Array<TArrayBuffer> | BigInt64Array<TArrayBuffer> | Float16Array<TArrayBuffer> | Float32Array<TArrayBuffer> | Float64Array<TArrayBuffer>;
+        type ArrayBufferView<TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> = TypedArray<TArrayBuffer> | DataView<TArrayBuffer>;
+        type NonSharedUint8Array = Uint8Array<ArrayBuffer>;
+        type NonSharedUint8ClampedArray = Uint8ClampedArray<ArrayBuffer>;
+        type NonSharedUint16Array = Uint16Array<ArrayBuffer>;
+        type NonSharedUint32Array = Uint32Array<ArrayBuffer>;
+        type NonSharedInt8Array = Int8Array<ArrayBuffer>;
+        type NonSharedInt16Array = Int16Array<ArrayBuffer>;
+        type NonSharedInt32Array = Int32Array<ArrayBuffer>;
+        type NonSharedBigUint64Array = BigUint64Array<ArrayBuffer>;
+        type NonSharedBigInt64Array = BigInt64Array<ArrayBuffer>;
+        type NonSharedFloat16Array = Float16Array<ArrayBuffer>;
+        type NonSharedFloat32Array = Float32Array<ArrayBuffer>;
+        type NonSharedFloat64Array = Float64Array<ArrayBuffer>;
+        type NonSharedDataView = DataView<ArrayBuffer>;
+        type NonSharedTypedArray = TypedArray<ArrayBuffer>;
+        type NonSharedArrayBufferView = ArrayBufferView<ArrayBuffer>;
+    }
+}

package/types/node/http.d.ts

@@ -0,0 +1,530 @@
+declare module "node:http" {
+    import { NonSharedBuffer } from "node:buffer";
+    import { LookupOptions } from "node:dns";
+    import { EventEmitter } from "node:events";
+    import * as net from "node:net";
+    import * as stream from "node:stream";
+    import { URL } from "node:url";
+    interface IncomingHttpHeaders extends NodeJS.Dict<string | string[]> {
+        accept?: string | undefined;
+        "accept-encoding"?: string | undefined;
+        "accept-language"?: string | undefined;
+        "accept-patch"?: string | undefined;
+        "accept-ranges"?: string | undefined;
+        "access-control-allow-credentials"?: string | undefined;
+        "access-control-allow-headers"?: string | undefined;
+        "access-control-allow-methods"?: string | undefined;
+        "access-control-allow-origin"?: string | undefined;
+        "access-control-expose-headers"?: string | undefined;
+        "access-control-max-age"?: string | undefined;
+        "access-control-request-headers"?: string | undefined;
+        "access-control-request-method"?: string | undefined;
+        age?: string | undefined;
+        allow?: string | undefined;
+        "alt-svc"?: string | undefined;
+        authorization?: string | undefined;
+        "cache-control"?: string | undefined;
+        connection?: string | undefined;
+        "content-disposition"?: string | undefined;
+        "content-encoding"?: string | undefined;
+        "content-language"?: string | undefined;
+        "content-length"?: string | undefined;
+        "content-location"?: string | undefined;
+        "content-range"?: string | undefined;
+        "content-type"?: string | undefined;
+        cookie?: string | undefined;
+        date?: string | undefined;
+        etag?: string | undefined;
+        expect?: string | undefined;
+        expires?: string | undefined;
+        forwarded?: string | undefined;
+        from?: string | undefined;
+        host?: string | undefined;
+        "if-match"?: string | undefined;
+        "if-modified-since"?: string | undefined;
+        "if-none-match"?: string | undefined;
+        "if-unmodified-since"?: string | undefined;
+        "last-modified"?: string | undefined;
+        location?: string | undefined;
+        origin?: string | undefined;
+        pragma?: string | undefined;
+        "proxy-authenticate"?: string | undefined;
+        "proxy-authorization"?: string | undefined;
+        "public-key-pins"?: string | undefined;
+        range?: string | undefined;
+        referer?: string | undefined;
+        "retry-after"?: string | undefined;
+        "sec-fetch-site"?: string | undefined;
+        "sec-fetch-mode"?: string | undefined;
+        "sec-fetch-user"?: string | undefined;
+        "sec-fetch-dest"?: string | undefined;
+        "sec-websocket-accept"?: string | undefined;
+        "sec-websocket-extensions"?: string | undefined;
+        "sec-websocket-key"?: string | undefined;
+        "sec-websocket-protocol"?: string | undefined;
+        "sec-websocket-version"?: string | undefined;
+        "set-cookie"?: string[] | undefined;
+        "strict-transport-security"?: string | undefined;
+        tk?: string | undefined;
+        trailer?: string | undefined;
+        "transfer-encoding"?: string | undefined;
+        upgrade?: string | undefined;
+        "user-agent"?: string | undefined;
+        vary?: string | undefined;
+        via?: string | undefined;
+        warning?: string | undefined;
+        "www-authenticate"?: string | undefined;
+    }
+    type OutgoingHttpHeader = number | string | string[];
+    interface OutgoingHttpHeaders extends NodeJS.Dict<OutgoingHttpHeader> {
+        accept?: string | string[] | undefined;
+        "accept-charset"?: string | string[] | undefined;
+        "accept-encoding"?: string | string[] | undefined;
+        "accept-language"?: string | string[] | undefined;
+        "accept-ranges"?: string | undefined;
+        "access-control-allow-credentials"?: string | undefined;
+        "access-control-allow-headers"?: string | undefined;
+        "access-control-allow-methods"?: string | undefined;
+        "access-control-allow-origin"?: string | undefined;
+        "access-control-expose-headers"?: string | undefined;
+        "access-control-max-age"?: string | undefined;
+        "access-control-request-headers"?: string | undefined;
+        "access-control-request-method"?: string | undefined;
+        age?: string | undefined;
+        allow?: string | undefined;
+        authorization?: string | undefined;
+        "cache-control"?: string | undefined;
+        "cdn-cache-control"?: string | undefined;
+        connection?: string | string[] | undefined;
+        "content-disposition"?: string | undefined;
+        "content-encoding"?: string | undefined;
+        "content-language"?: string | undefined;
+        "content-length"?: string | number | undefined;
+        "content-location"?: string | undefined;
+        "content-range"?: string | undefined;
+        "content-security-policy"?: string | undefined;
+        "content-security-policy-report-only"?: string | undefined;
+        "content-type"?: string | undefined;
+        cookie?: string | string[] | undefined;
+        dav?: string | string[] | undefined;
+        dnt?: string | undefined;
+        date?: string | undefined;
+        etag?: string | undefined;
+        expect?: string | undefined;
+        expires?: string | undefined;
+        forwarded?: string | undefined;
+        from?: string | undefined;
+        host?: string | undefined;
+        "if-match"?: string | undefined;
+        "if-modified-since"?: string | undefined;
+        "if-none-match"?: string | undefined;
+        "if-range"?: string | undefined;
+        "if-unmodified-since"?: string | undefined;
+        "last-modified"?: string | undefined;
+        link?: string | string[] | undefined;
+        location?: string | undefined;
+        "max-forwards"?: string | undefined;
+        origin?: string | undefined;
+        pragma?: string | string[] | undefined;
+        "proxy-authenticate"?: string | string[] | undefined;
+        "proxy-authorization"?: string | undefined;
+        "public-key-pins"?: string | undefined;
+        "public-key-pins-report-only"?: string | undefined;
+        range?: string | undefined;
+        referer?: string | undefined;
+        "referrer-policy"?: string | undefined;
+        refresh?: string | undefined;
+        "retry-after"?: string | undefined;
+        "sec-websocket-accept"?: string | undefined;
+        "sec-websocket-extensions"?: string | string[] | undefined;
+        "sec-websocket-key"?: string | undefined;
+        "sec-websocket-protocol"?: string | string[] | undefined;
+        "sec-websocket-version"?: string | undefined;
+        server?: string | undefined;
+        "set-cookie"?: string | string[] | undefined;
+        "strict-transport-security"?: string | undefined;
+        te?: string | undefined;
+        trailer?: string | undefined;
+        "transfer-encoding"?: string | undefined;
+        "user-agent"?: string | undefined;
+        upgrade?: string | undefined;
+        "upgrade-insecure-requests"?: string | undefined;
+        vary?: string | undefined;
+        via?: string | string[] | undefined;
+        warning?: string | undefined;
+        "www-authenticate"?: string | string[] | undefined;
+        "x-content-type-options"?: string | undefined;
+        "x-dns-prefetch-control"?: string | undefined;
+        "x-frame-options"?: string | undefined;
+        "x-xss-protection"?: string | undefined;
+    }
+    interface ClientRequestArgs extends Pick<LookupOptions, "hints"> {
+        _defaultAgent?: Agent | undefined;
+        agent?: Agent | boolean | undefined;
+        auth?: string | null | undefined;
+        createConnection?: ((options: ClientRequestArgs, oncreate: (err: Error | null, socket: stream.Duplex) => void) => stream.Duplex | null | undefined) | undefined;
+        defaultPort?: number | string | undefined;
+        family?: number | undefined;
+        headers?: OutgoingHttpHeaders | readonly string[] | undefined;
+        host?: string | null | undefined;
+        hostname?: string | null | undefined;
+        insecureHTTPParser?: boolean | undefined;
+        localAddress?: string | undefined;
+        localPort?: number | undefined;
+        lookup?: net.LookupFunction | undefined;
+        maxHeaderSize?: number | undefined;
+        method?: string | undefined;
+        path?: string | null | undefined;
+        port?: number | string | null | undefined;
+        protocol?: string | null | undefined;
+        setDefaultHeaders?: boolean | undefined;
+        setHost?: boolean | undefined;
+        signal?: AbortSignal | undefined;
+        socketPath?: string | undefined;
+        timeout?: number | undefined;
+        uniqueHeaders?: Array<string | string[]> | undefined;
+        joinDuplicateHeaders?: boolean | undefined;
+    }
+    interface ServerOptions<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse> {
+        IncomingMessage?: Request | undefined;
+        ServerResponse?: Response | undefined;
+        requestTimeout?: number | undefined;
+        joinDuplicateHeaders?: boolean | undefined;
+        keepAliveTimeout?: number | undefined;
+        keepAliveTimeoutBuffer?: number | undefined;
+        connectionsCheckingInterval?: number | undefined;
+        headersTimeout?: number | undefined;
+        highWaterMark?: number | undefined;
+        insecureHTTPParser?: boolean | undefined;
+        maxHeaderSize?: number | undefined;
+        noDelay?: boolean | undefined;
+        requireHostHeader?: boolean | undefined;
+        keepAlive?: boolean | undefined;
+        keepAliveInitialDelay?: number | undefined;
+        uniqueHeaders?: Array<string | string[]> | undefined;
+        shouldUpgradeCallback?: ((request: InstanceType<Request>) => boolean) | undefined;
+        rejectNonStandardBodyWrites?: boolean | undefined;
+        optimizeEmptyRequests?: boolean | undefined;
+    }
+    type RequestListener<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse> = (request: InstanceType<Request>, response: InstanceType<Response> & {
+        req: InstanceType<Request>;
+    }) => void;
+    interface ServerEventMap<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse> extends net.ServerEventMap {
+        "checkContinue": Parameters<RequestListener<Request, Response>>;
+        "checkExpectation": Parameters<RequestListener<Request, Response>>;
+        "clientError": [
+            exception: Error,
+            socket: stream.Duplex
+        ];
+        "connect": [
+            request: InstanceType<Request>,
+            socket: stream.Duplex,
+            head: NonSharedBuffer
+        ];
+        "connection": [
+            socket: net.Socket
+        ];
+        "dropRequest": [
+            request: InstanceType<Request>,
+            socket: stream.Duplex
+        ];
+        "request": Parameters<RequestListener<Request, Response>>;
+        "upgrade": [
+            req: InstanceType<Request>,
+            socket: stream.Duplex,
+            head: NonSharedBuffer
+        ];
+    }
+    class Server<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse> extends net.Server {
+        constructor(requestListener?: RequestListener<Request, Response>);
+        constructor(options: ServerOptions<Request, Response>, requestListener?: RequestListener<Request, Response>);
+        setTimeout(msecs?: number, callback?: (socket: net.Socket) => void): this;
+        setTimeout(callback: (socket: net.Socket) => void): this;
+        maxHeadersCount: number | null;
+        maxRequestsPerSocket: number | null;
+        timeout: number;
+        headersTimeout: number;
+        keepAliveTimeout: number;
+        keepAliveTimeoutBuffer: number;
+        requestTimeout: number;
+        closeAllConnections(): void;
+        closeIdleConnections(): void;
+        addListener<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ServerEventMap>(eventName: E, ...args: ServerEventMap<Request, Response>[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ServerEventMap>(eventName: E, listener?: (...args: ServerEventMap<Request, Response>[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ServerEventMap>(eventName: E): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ServerEventMap>(eventName: E): ((...args: ServerEventMap<Request, Response>[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof ServerEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ServerEventMap>(eventName: E, listener: (...args: ServerEventMap<Request, Response>[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    interface OutgoingMessageEventMap extends stream.WritableEventMap {
+        "prefinish": [
+        ];
+    }
+    class OutgoingMessage<Request extends IncomingMessage = IncomingMessage> extends stream.Writable {
+        constructor();
+        readonly req: Request;
+        chunkedEncoding: boolean;
+        shouldKeepAlive: boolean;
+        useChunkedEncodingByDefault: boolean;
+        sendDate: boolean;
+        finished: boolean;
+        readonly headersSent: boolean;
+        readonly connection: net.Socket | null;
+        readonly socket: net.Socket | null;
+        setTimeout(msecs: number, callback?: () => void): this;
+        setHeader(name: string, value: number | string | readonly string[]): this;
+        setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
+        appendHeader(name: string, value: string | readonly string[]): this;
+        getHeader(name: string): number | string | string[] | undefined;
+        getHeaders(): OutgoingHttpHeaders;
+        getHeaderNames(): string[];
+        hasHeader(name: string): boolean;
+        removeHeader(name: string): void;
+        addTrailers(headers: OutgoingHttpHeaders | ReadonlyArray<[
+            string,
+            string
+        ]>): void;
+        flushHeaders(): void;
+        addListener<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof OutgoingMessageEventMap>(eventName: E, ...args: OutgoingMessageEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof OutgoingMessageEventMap>(eventName: E, listener?: (...args: OutgoingMessageEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof OutgoingMessageEventMap>(eventName: E): ((...args: OutgoingMessageEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof OutgoingMessageEventMap>(eventName: E): ((...args: OutgoingMessageEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof OutgoingMessageEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof OutgoingMessageEventMap>(eventName: E, listener: (...args: OutgoingMessageEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    class ServerResponse<Request extends IncomingMessage = IncomingMessage> extends OutgoingMessage<Request> {
+        statusCode: number;
+        statusMessage: string;
+        strictContentLength: boolean;
+        constructor(req: Request);
+        assignSocket(socket: net.Socket): void;
+        detachSocket(socket: net.Socket): void;
+        writeContinue(callback?: () => void): void;
+        writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
+        writeHead(statusCode: number, statusMessage?: string, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+        writeHead(statusCode: number, headers?: OutgoingHttpHeaders | OutgoingHttpHeader[]): this;
+        writeProcessing(callback?: () => void): void;
+    }
+    interface InformationEvent {
+        httpVersion: string;
+        httpVersionMajor: number;
+        httpVersionMinor: number;
+        statusCode: number;
+        statusMessage: string;
+        headers: IncomingHttpHeaders;
+        rawHeaders: string[];
+    }
+    interface ClientRequestEventMap extends stream.WritableEventMap {
+        "abort": [
+        ];
+        "connect": [
+            response: IncomingMessage,
+            socket: net.Socket,
+            head: NonSharedBuffer
+        ];
+        "continue": [
+        ];
+        "information": [
+            info: InformationEvent
+        ];
+        "response": [
+            response: IncomingMessage
+        ];
+        "socket": [
+            socket: net.Socket
+        ];
+        "timeout": [
+        ];
+        "upgrade": [
+            response: IncomingMessage,
+            socket: net.Socket,
+            head: NonSharedBuffer
+        ];
+    }
+    class ClientRequest extends OutgoingMessage {
+        aborted: boolean;
+        host: string;
+        protocol: string;
+        reusedSocket: boolean;
+        maxHeadersCount: number;
+        constructor(url: string | URL | ClientRequestArgs, cb?: (res: IncomingMessage) => void);
+        method: string;
+        path: string;
+        abort(): void;
+        onSocket(socket: net.Socket): void;
+        setTimeout(timeout: number, callback?: () => void): this;
+        setNoDelay(noDelay?: boolean): void;
+        setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+        getRawHeaderNames(): string[];
+        addListener<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ClientRequestEventMap>(eventName: E, ...args: ClientRequestEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ClientRequestEventMap>(eventName: E, listener?: (...args: ClientRequestEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ClientRequestEventMap>(eventName: E): ((...args: ClientRequestEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ClientRequestEventMap>(eventName: E): ((...args: ClientRequestEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof ClientRequestEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ClientRequestEventMap>(eventName: E, listener: (...args: ClientRequestEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    interface IncomingMessageEventMap extends stream.ReadableEventMap {
+        "aborted": [
+        ];
+    }
+    class IncomingMessage extends stream.Readable {
+        constructor(socket: net.Socket);
+        aborted: boolean;
+        httpVersion: string;
+        httpVersionMajor: number;
+        httpVersionMinor: number;
+        complete: boolean;
+        connection: net.Socket;
+        socket: net.Socket;
+        headers: IncomingHttpHeaders;
+        headersDistinct: NodeJS.Dict<string[]>;
+        rawHeaders: string[];
+        trailers: NodeJS.Dict<string>;
+        trailersDistinct: NodeJS.Dict<string[]>;
+        rawTrailers: string[];
+        setTimeout(msecs: number, callback?: () => void): this;
+        method?: string | undefined;
+        url?: string | undefined;
+        statusCode?: number | undefined;
+        statusMessage?: string | undefined;
+        destroy(error?: Error): this;
+        addListener<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof IncomingMessageEventMap>(eventName: E, ...args: IncomingMessageEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof IncomingMessageEventMap>(eventName: E, listener?: (...args: IncomingMessageEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof IncomingMessageEventMap>(eventName: E): ((...args: IncomingMessageEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof IncomingMessageEventMap>(eventName: E): ((...args: IncomingMessageEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof IncomingMessageEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof IncomingMessageEventMap>(eventName: E, listener: (...args: IncomingMessageEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    interface ProxyEnv extends NodeJS.ProcessEnv {
+        HTTP_PROXY?: string | undefined;
+        HTTPS_PROXY?: string | undefined;
+        NO_PROXY?: string | undefined;
+        http_proxy?: string | undefined;
+        https_proxy?: string | undefined;
+        no_proxy?: string | undefined;
+    }
+    interface AgentOptions extends NodeJS.PartialOptions<net.TcpSocketConnectOpts> {
+        keepAlive?: boolean | undefined;
+        keepAliveMsecs?: number | undefined;
+        agentKeepAliveTimeoutBuffer?: number | undefined;
+        maxSockets?: number | undefined;
+        maxTotalSockets?: number | undefined;
+        maxFreeSockets?: number | undefined;
+        timeout?: number | undefined;
+        scheduling?: "fifo" | "lifo" | undefined;
+        proxyEnv?: ProxyEnv | undefined;
+        defaultPort?: number | undefined;
+        protocol?: string | undefined;
+    }
+    class Agent extends EventEmitter {
+        maxFreeSockets: number;
+        maxSockets: number;
+        maxTotalSockets: number;
+        readonly freeSockets: NodeJS.ReadOnlyDict<net.Socket[]>;
+        readonly sockets: NodeJS.ReadOnlyDict<net.Socket[]>;
+        readonly requests: NodeJS.ReadOnlyDict<ClientRequest[]>;
+        constructor(opts?: AgentOptions);
+        destroy(): void;
+        createConnection(options: ClientRequestArgs, callback?: (err: Error | null, stream: stream.Duplex) => void): stream.Duplex | null | undefined;
+        keepSocketAlive(socket: stream.Duplex): void;
+        reuseSocket(socket: stream.Duplex, request: ClientRequest): void;
+        getName(options?: ClientRequestArgs): string;
+    }
+    const METHODS: string[];
+    const STATUS_CODES: {
+        [errorCode: number]: string | undefined;
+        [errorCode: string]: string | undefined;
+    };
+    function createServer<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse>(requestListener?: RequestListener<Request, Response>): Server<Request, Response>;
+    function createServer<Request extends typeof IncomingMessage = typeof IncomingMessage, Response extends typeof ServerResponse<InstanceType<Request>> = typeof ServerResponse>(options: ServerOptions<Request, Response>, requestListener?: RequestListener<Request, Response>): Server<Request, Response>;
+    interface RequestOptions extends ClientRequestArgs {
+    }
+    function request(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest;
+    function request(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+    function get(options: RequestOptions | string | URL, callback?: (res: IncomingMessage) => void): ClientRequest;
+    function get(url: string | URL, options: RequestOptions, callback?: (res: IncomingMessage) => void): ClientRequest;
+    function validateHeaderName(name: string): void;
+    function validateHeaderValue(name: string, value: string): void;
+    function setMaxIdleHTTPParsers(max: number): void;
+    function setGlobalProxyFromEnv(proxyEnv?: ProxyEnv): () => void;
+    let globalAgent: Agent;
+    const maxHeaderSize: number;
+    const WebSocket: typeof import("../undici/index").WebSocket;
+    const CloseEvent: typeof import("../undici/index").CloseEvent;
+    const MessageEvent: typeof import("../undici/index").MessageEvent;
+}
+declare module "http" {
+    export * from "node:http";
+}