@secure-exec/nodejs 0.2.0-rc.1

package/dist/bridge/network.d.ts

@@ -0,0 +1,1093 @@
+import type * as nodeHttp from "http";
+import type * as nodeDgram from "node:dgram";
+interface FetchOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | null;
+    mode?: string;
+    credentials?: string;
+    cache?: string;
+    redirect?: string;
+    referrer?: string;
+    integrity?: string;
+}
+interface FetchResponse {
+    ok: boolean;
+    status: number;
+    statusText: string;
+    headers: Map<string, string>;
+    url: string;
+    redirected: boolean;
+    type: string;
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    blob(): Promise<never>;
+    clone(): FetchResponse;
+}
+export declare function fetch(input: string | URL | Request, options?: FetchOptions): Promise<FetchResponse>;
+export declare class Headers {
+    private _headers;
+    constructor(init?: HeadersInit | Headers | Record<string, string> | [string, string][]);
+    get(name: string): string | null;
+    set(name: string, value: string): void;
+    has(name: string): boolean;
+    delete(name: string): void;
+    entries(): IterableIterator<[string, string]>;
+    [Symbol.iterator](): IterableIterator<[string, string]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<string>;
+    append(name: string, value: string): void;
+    forEach(callback: (value: string, key: string, parent: Headers) => void): void;
+}
+export declare class Request {
+    url: string;
+    method: string;
+    headers: Headers;
+    body: string | null;
+    mode: string;
+    credentials: string;
+    cache: string;
+    redirect: string;
+    referrer: string;
+    integrity: string;
+    constructor(input: string | Request, init?: FetchOptions);
+    clone(): Request;
+}
+export declare class Response {
+    private _body;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    ok: boolean;
+    type: string;
+    url: string;
+    redirected: boolean;
+    constructor(body?: string | null, init?: {
+        status?: number;
+        statusText?: string;
+        headers?: Record<string, string>;
+    });
+    text(): Promise<string>;
+    json(): Promise<unknown>;
+    get body(): {
+        getReader(): {
+            read(): Promise<{
+                done: boolean;
+                value?: Uint8Array;
+            }>;
+        };
+    } | null;
+    clone(): Response;
+    static error(): Response;
+    static redirect(url: string, status?: number): Response;
+}
+type DnsCallback = (err: Error | null, address?: string, family?: number) => void;
+type DnsResolveCallback = (err: Error | null, addresses?: string[]) => void;
+export declare const dns: {
+    lookup(hostname: string, options: unknown, callback?: DnsCallback): void;
+    resolve(hostname: string, rrtype: string | DnsResolveCallback, callback?: DnsResolveCallback): void;
+    resolve4(hostname: string, callback: DnsResolveCallback): void;
+    resolve6(hostname: string, callback: DnsResolveCallback): void;
+    promises: {
+        lookup(hostname: string, _options?: unknown): Promise<{
+            address: string;
+            family: number;
+        }>;
+        resolve(hostname: string, rrtype?: string): Promise<string[]>;
+    };
+};
+type EventListener = (...args: unknown[]) => void;
+type RequestSocketLike = {
+    destroyed: boolean;
+    readable?: boolean;
+    writable?: boolean;
+    timeout?: number;
+    _freeTimer?: ReturnType<typeof setTimeout> | null;
+    on(event: string, listener: EventListener): unknown;
+    once(event: string, listener: EventListener): unknown;
+    off?(event: string, listener: EventListener): unknown;
+    removeListener?(event: string, listener: EventListener): unknown;
+    removeAllListeners?(event?: string): unknown;
+    emit?(event: string, ...args: unknown[]): boolean;
+    listeners?(event: string): EventListener[];
+    listenerCount?(event: string): number;
+    setTimeout?(timeout: number, callback?: () => void): unknown;
+    setNoDelay?(noDelay?: boolean): unknown;
+    setKeepAlive?(enable?: boolean, delay?: number): unknown;
+    end?(...args: unknown[]): unknown;
+    destroy(error?: Error): unknown;
+};
+/**
+ * Polyfill of Node.js `http.IncomingMessage` (client-side response). Buffers
+ * the response body eagerly and emits `data`/`end` events on listener
+ * registration (flowing mode). Supports base64 binary decoding via
+ * `x-body-encoding` header.
+ */
+export declare class IncomingMessage {
+    headers: Record<string, string | string[]>;
+    rawHeaders: string[];
+    trailers: Record<string, string>;
+    rawTrailers: string[];
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    method: string | null;
+    url: string;
+    statusCode: number | undefined;
+    statusMessage: string | undefined;
+    private _body;
+    private _isBinary;
+    private _listeners;
+    complete: boolean;
+    aborted: boolean;
+    socket: FakeSocket | UpgradeSocket | DirectTunnelSocket | null;
+    private _bodyConsumed;
+    private _ended;
+    private _flowing;
+    readable: boolean;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    destroyed: boolean;
+    private _encoding?;
+    private _closeEmitted;
+    constructor(response?: {
+        headers?: Record<string, string | string[]> | Array<[string, string]>;
+        rawHeaders?: string[];
+        url?: string;
+        status?: number;
+        statusText?: string;
+        body?: string;
+        trailers?: Record<string, string>;
+        bodyEncoding?: "utf8" | "base64";
+    });
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    setEncoding(encoding: string): this;
+    read(_size?: number): string | Buffer | null;
+    pipe<T extends NodeJS.WritableStream>(dest: T): T;
+    pause(): this;
+    resume(): this;
+    unpipe(_dest?: NodeJS.WritableStream): this;
+    destroy(err?: Error): this;
+    _abort(err?: Error): void;
+    private _emitClose;
+    [Symbol.asyncIterator](): AsyncIterator<string | Buffer>;
+}
+/**
+ * Polyfill of Node.js `http.ClientRequest`. Executes the request asynchronously
+ * via the `_networkHttpRequestRaw` bridge and emits a `response` event with
+ * an IncomingMessage. Supports Agent-based connection pooling, socket events,
+ * HTTP upgrade (101), and trailer headers.
+ */
+export declare class ClientRequest {
+    private _options;
+    private _callback?;
+    private _listeners;
+    private _headers;
+    private _rawHeaderNames;
+    private _body;
+    private _bodyBytes;
+    private _ended;
+    private _agent;
+    private _hostKey;
+    private _socketEndListener;
+    private _socketCloseListener;
+    private _loopbackAbort?;
+    private _response;
+    private _closeEmitted;
+    private _abortEmitted;
+    private _signalAbortHandler?;
+    private _signalPollTimer;
+    private _skipExecute;
+    private _destroyError;
+    private _errorEmitted;
+    socket: RequestSocketLike;
+    finished: boolean;
+    aborted: boolean;
+    destroyed: boolean;
+    path: string;
+    method: string;
+    reusedSocket: boolean;
+    timeoutCb?: () => void;
+    constructor(options: nodeHttp.RequestOptions, callback?: (res: IncomingMessage) => void);
+    _assignSocket(socket: RequestSocketLike, reusedSocket: boolean): void;
+    _handleSocketError(err: Error): void;
+    private _finalizeSocket;
+    private _dispatchWithSocket;
+    private _execute;
+    private _buildUrl;
+    on(event: string, listener: EventListener): this;
+    addListener(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    getHeader(name: string): string | string[] | undefined;
+    getHeaders(): Record<string, string | string[]>;
+    getHeaderNames(): string[];
+    getRawHeaderNames(): string[];
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    private _emit;
+    private _listenerCount;
+    private _setOutgoingHeaders;
+    private _setHeaderValue;
+    write(data: string): boolean;
+    end(data?: string): this;
+    abort(): void;
+    destroy(err?: Error): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    setNoDelay(): this;
+    setSocketKeepAlive(): this;
+    flushHeaders(): void;
+    private _emitClose;
+    private _applyTimeoutToSocket;
+    private _validateTimeoutOption;
+    private _bindAbortSignal;
+    private _unbindAbortSignal;
+    private _startAbortSignalPoll;
+    private _clearTimeout;
+}
+declare class FakeSocket {
+    remoteAddress: string;
+    remotePort: number;
+    localAddress: string;
+    localPort: number;
+    connecting: boolean;
+    destroyed: boolean;
+    writable: boolean;
+    readable: boolean;
+    timeout: number;
+    private _listeners;
+    private _closed;
+    private _closeScheduled;
+    private _timeoutTimer;
+    _freeTimer: ReturnType<typeof setTimeout> | null;
+    constructor(options?: {
+        host?: string;
+        port?: number;
+    });
+    setTimeout(ms: number, cb?: () => void): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setKeepAlive(_enable?: boolean, _delay?: number): this;
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    listenerCount(event: string): number;
+    listeners(event: string): EventListener[];
+    write(_data: unknown): boolean;
+    end(): this;
+    destroy(): this;
+}
+declare class DirectTunnelSocket {
+    remoteAddress: string;
+    remotePort: number;
+    localAddress: string;
+    localPort: number;
+    connecting: boolean;
+    destroyed: boolean;
+    writable: boolean;
+    readable: boolean;
+    readyState: string;
+    bytesWritten: number;
+    private _listeners;
+    private _encoding?;
+    private _peer;
+    _readableState: {
+        endEmitted: boolean;
+    };
+    _writableState: {
+        finished: boolean;
+        errorEmitted: boolean;
+    };
+    constructor(options?: {
+        host?: string;
+        port?: number;
+    });
+    _attachPeer(peer: DirectTunnelSocket): void;
+    setTimeout(_ms: number, _cb?: () => void): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setKeepAlive(_enable?: boolean, _delay?: number): this;
+    setEncoding(encoding: BufferEncoding): this;
+    ref(): this;
+    unref(): this;
+    cork(): void;
+    uncork(): void;
+    pause(): this;
+    resume(): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    on(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    listenerCount(event: string): number;
+    write(data: unknown, encodingOrCb?: string | (() => void), cb?: (() => void)): boolean;
+    end(data?: unknown): this;
+    destroy(err?: Error): this;
+    _pushData(buffer: Buffer): void;
+    _pushEnd(): void;
+}
+declare class UpgradeSocket {
+    remoteAddress: string;
+    remotePort: number;
+    localAddress: string;
+    localPort: number;
+    connecting: boolean;
+    destroyed: boolean;
+    writable: boolean;
+    readable: boolean;
+    readyState: string;
+    bytesWritten: number;
+    private _listeners;
+    private _socketId;
+    _readableState: {
+        endEmitted: boolean;
+    };
+    _writableState: {
+        finished: boolean;
+        errorEmitted: boolean;
+    };
+    constructor(socketId: number, options?: {
+        host?: string;
+        port?: number;
+    });
+    setTimeout(_ms: number, _cb?: () => void): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setKeepAlive(_enable?: boolean, _delay?: number): this;
+    ref(): this;
+    unref(): this;
+    cork(): void;
+    uncork(): void;
+    pause(): this;
+    resume(): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+    on(event: string, listener: EventListener): this;
+    addListener(event: string, listener: EventListener): this;
+    once(event: string, listener: EventListener): this;
+    off(event: string, listener: EventListener): this;
+    removeListener(event: string, listener: EventListener): this;
+    removeAllListeners(event?: string): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    listenerCount(event: string): number;
+    [key: string | symbol]: unknown;
+    write(data: unknown, encodingOrCb?: string | (() => void), cb?: (() => void)): boolean;
+    end(data?: unknown): this;
+    destroy(err?: Error): this;
+    _pushData(data: Buffer | Uint8Array): void;
+    _pushEnd(): void;
+}
+export declare const http: Record<string, unknown>;
+export declare const https: Record<string, unknown>;
+type Http2HeaderValue = string | string[] | number;
+type Http2HeadersRecord = Record<string, Http2HeaderValue>;
+type Http2SettingsRecord = Record<string, boolean | number | Record<number, number>>;
+type Http2SessionRuntimeState = {
+    effectiveLocalWindowSize?: number;
+    localWindowSize?: number;
+    remoteWindowSize?: number;
+    nextStreamID?: number;
+    outboundQueueSize?: number;
+    deflateDynamicTableSize?: number;
+    inflateDynamicTableSize?: number;
+};
+type Http2EventListener = (...args: unknown[]) => void;
+type SerializedHttp2SocketState = {
+    encrypted?: boolean;
+    allowHalfOpen?: boolean;
+    localAddress?: string;
+    localPort?: number;
+    localFamily?: string;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    servername?: string;
+    alpnProtocol?: string | false;
+};
+declare class Http2EventEmitter {
+    private _listeners;
+    private _onceListeners;
+    on(event: string, listener: Http2EventListener): this;
+    addListener(event: string, listener: Http2EventListener): this;
+    once(event: string, listener: Http2EventListener): this;
+    removeListener(event: string, listener: Http2EventListener): this;
+    off(event: string, listener: Http2EventListener): this;
+    listenerCount(event: string): number;
+    setMaxListeners(_value: number): this;
+    emit(event: string, ...args: unknown[]): boolean;
+}
+declare class Http2SocketProxy extends Http2EventEmitter {
+    allowHalfOpen: boolean;
+    encrypted: boolean;
+    localAddress: string;
+    localPort: number;
+    localFamily: string;
+    remoteAddress: string;
+    remotePort: number;
+    remoteFamily: string;
+    servername?: string;
+    alpnProtocol: string | false;
+    destroyed: boolean;
+    private _onDestroy?;
+    constructor(state?: SerializedHttp2SocketState, onDestroy?: () => void);
+    _applyState(state?: SerializedHttp2SocketState): void;
+    end(): this;
+    destroy(): this;
+}
+declare class ClientHttp2Stream extends Http2EventEmitter {
+    private _streamId;
+    private _encoding?;
+    private _utf8Remainder?;
+    private _isPushStream;
+    private _session?;
+    private _receivedResponse;
+    private _needsDrain;
+    private _pendingWritableBytes;
+    private _drainScheduled;
+    private readonly _writableHighWaterMark;
+    rstCode: number;
+    readable: boolean;
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    destroyed: boolean;
+    _writableState: {
+        ended: boolean;
+        finished: boolean;
+        objectMode: boolean;
+        corked: number;
+        length: number;
+    };
+    constructor(streamId: number, session?: Http2Session, isPushStream?: boolean);
+    setEncoding(encoding: string): this;
+    close(): this;
+    destroy(error?: Error): this;
+    private _scheduleDrain;
+    write(data: unknown, encodingOrCallback?: BufferEncoding | (() => void), callback?: () => void): boolean;
+    end(data?: unknown): this;
+    resume(): this;
+    _emitPush(headers: Http2HeadersRecord, flags?: number): void;
+    _hasReceivedResponse(): boolean;
+    _belongsTo(session: Http2Session): boolean;
+    _emitResponseHeaders(headers: Http2HeadersRecord): void;
+    _emitDataChunk(dataBase64?: string): void;
+    _emitEnd(): void;
+    _emitClose(rstCode?: number): void;
+}
+declare class ServerHttp2Stream extends Http2EventEmitter {
+    private _streamId;
+    private _responded;
+    private _requestHeaders?;
+    private _isPushStream;
+    session: Http2Session;
+    rstCode: number;
+    readable: boolean;
+    writable: boolean;
+    destroyed: boolean;
+    _readableState: {
+        flowing: boolean | null;
+        ended: boolean;
+        highWaterMark: number;
+    };
+    _writableState: {
+        ended: boolean;
+    };
+    constructor(streamId: number, session: Http2Session, requestHeaders?: Http2HeadersRecord, isPushStream?: boolean);
+    respond(headers?: Http2HeadersRecord): void;
+    pushStream(headers: Http2HeadersRecord, optionsOrCallback?: Record<string, unknown> | ((error: Error | null, stream?: ServerHttp2Stream, headers?: Http2HeadersRecord) => void), maybeCallback?: (error: Error | null, stream?: ServerHttp2Stream, headers?: Http2HeadersRecord) => void): void;
+    write(data: unknown): boolean;
+    end(data?: unknown): void;
+    pause(): this;
+    resume(): this;
+    respondWithFile(path: string, headers?: Record<string, unknown>, options?: Record<string, unknown>): void;
+    respondWithFD(fdOrHandle: number | {
+        fd?: unknown;
+    }, headers?: Record<string, unknown>, options?: Record<string, unknown>): void;
+    _emitData(dataBase64?: string): void;
+    _emitEnd(): void;
+    _emitDrain(): void;
+    _emitClose(rstCode?: number): void;
+}
+declare class Http2ServerRequest extends Http2EventEmitter {
+    headers: Http2HeadersRecord;
+    method: string;
+    url: string;
+    connection: Http2SocketProxy;
+    socket: Http2SocketProxy;
+    stream: ServerHttp2Stream;
+    destroyed: boolean;
+    readable: boolean;
+    _readableState: {
+        flowing: boolean | null;
+        length: number;
+        ended: boolean;
+        objectMode: boolean;
+    };
+    constructor(headers: Http2HeadersRecord, socket: Http2SocketProxy, stream: ServerHttp2Stream);
+    on(event: string, listener: Http2EventListener): this;
+    once(event: string, listener: Http2EventListener): this;
+    resume(): this;
+    pause(): this;
+    pipe(dest: {
+        write: (chunk: Buffer) => boolean;
+        end: () => void;
+        once?: (event: string, listener: () => void) => unknown;
+    }): typeof dest;
+    unpipe(): this;
+    read(): null;
+    isPaused(): boolean;
+    setEncoding(): this;
+    _emitData(chunk: Buffer): void;
+    _emitEnd(): void;
+    _emitError(error: Error): void;
+    destroy(err?: Error): this;
+}
+declare class Http2ServerResponse extends Http2EventEmitter {
+    private _stream;
+    private _headers;
+    private _statusCode;
+    headersSent: boolean;
+    writable: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    socket: Http2SocketProxy;
+    connection: Http2SocketProxy;
+    stream: ServerHttp2Stream;
+    _writableState: {
+        ended: boolean;
+        finished: boolean;
+        objectMode: boolean;
+        corked: number;
+        length: number;
+    };
+    constructor(stream: ServerHttp2Stream);
+    writeHead(statusCode: number, headers?: Http2HeadersRecord): this;
+    setHeader(name: string, value: Http2HeaderValue): this;
+    getHeader(name: string): Http2HeaderValue | undefined;
+    hasHeader(name: string): boolean;
+    removeHeader(name: string): void;
+    write(data: unknown, encodingOrCallback?: BufferEncoding | (() => void), callback?: () => void): boolean;
+    end(data?: unknown): this;
+    destroy(err?: Error): this;
+}
+declare class Http2Session extends Http2EventEmitter {
+    encrypted: boolean;
+    alpnProtocol: string | false;
+    originSet?: string[];
+    localSettings: Http2SettingsRecord;
+    remoteSettings: Http2SettingsRecord;
+    pendingSettingsAck: boolean;
+    socket: Http2SocketProxy;
+    state: Http2SessionRuntimeState;
+    private _sessionId;
+    private _waitStarted;
+    private _pendingSettingsAckCount;
+    private _awaitingInitialSettingsAck;
+    private _settingsCallbacks;
+    constructor(sessionId: number, socketState?: SerializedHttp2SocketState);
+    _retain(): void;
+    _release(): void;
+    _beginInitialSettingsAck(): void;
+    _applyLocalSettings(settings: Http2SettingsRecord): void;
+    _applyRemoteSettings(settings: Http2SettingsRecord): void;
+    _applyRuntimeState(state?: Http2SessionRuntimeState): void;
+    _ackSettings(): void;
+    request(headers?: Http2HeadersRecord, options?: Record<string, unknown>): ClientHttp2Stream;
+    settings(settings: Record<string, unknown>, callback?: () => void): void;
+    setLocalWindowSize(windowSize: unknown): void;
+    goaway(code?: number, lastStreamID?: number, opaqueData?: unknown): void;
+    close(): void;
+    destroy(): void;
+}
+declare class Http2Server extends Http2EventEmitter {
+    readonly allowHalfOpen: boolean;
+    readonly allowHTTP1: boolean;
+    readonly encrypted: boolean;
+    readonly _serverId: number;
+    listening: boolean;
+    private _address;
+    private _options;
+    private _timeoutMs;
+    private _waitStarted;
+    constructor(options: Record<string, unknown> | undefined, listener: ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined, encrypted: boolean);
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | null;
+    _retain(): void;
+    _release(): void;
+    setTimeout(timeout: number, callback?: () => void): this;
+    updateSettings(settings: Record<string, unknown>): this;
+    listen(portOrOptions?: number | string | null | {
+        port?: unknown;
+        host?: unknown;
+        backlog?: unknown;
+        path?: unknown;
+    }, hostOrCallback?: string | NetServerEventListener, backlogOrCallback?: number | NetServerEventListener, callback?: NetServerEventListener): this;
+    close(callback?: () => void): this;
+}
+declare function connectHttp2(authorityOrOptions: unknown, optionsOrListener?: Record<string, unknown> | ((session: Http2Session) => void), maybeListener?: (session: Http2Session) => void): Http2Session;
+export declare const http2: {
+    Http2ServerRequest: typeof Http2ServerRequest;
+    Http2ServerResponse: typeof Http2ServerResponse;
+    constants: Record<string, string | number>;
+    getDefaultSettings(): Http2SettingsRecord;
+    connect: typeof connectHttp2;
+    createServer: (optionsOrListener?: Record<string, unknown> | ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined, maybeListener?: ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined) => Http2Server;
+    createSecureServer: (optionsOrListener?: Record<string, unknown> | ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined, maybeListener?: ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined) => Http2Server;
+};
+type NetEventListener = (...args: unknown[]) => void;
+type NetSocketInfo = {
+    localAddress: string;
+    localPort: number;
+    localFamily: string;
+    localPath?: string;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    remotePath?: string;
+};
+type SerializedTlsDataValue = {
+    kind: "buffer";
+    data: string;
+} | {
+    kind: "string";
+    data: string;
+};
+type SerializedTlsMaterial = SerializedTlsDataValue | SerializedTlsDataValue[];
+type SerializedTlsBridgeOptions = {
+    isServer?: boolean;
+    servername?: string;
+    rejectUnauthorized?: boolean;
+    requestCert?: boolean;
+    session?: string;
+    key?: SerializedTlsMaterial;
+    cert?: SerializedTlsMaterial;
+    ca?: SerializedTlsMaterial;
+    passphrase?: string;
+    ciphers?: string;
+    ALPNProtocols?: string[];
+    minVersion?: string;
+    maxVersion?: string;
+};
+type TlsSecureContextWrapper = {
+    __secureExecTlsContext: SerializedTlsBridgeOptions;
+    context: Record<string, unknown>;
+};
+type SerializedTlsState = {
+    authorized?: boolean;
+    authorizationError?: string;
+    alpnProtocol?: string | false;
+    servername?: string;
+    protocol?: string | null;
+    sessionReused?: boolean;
+    cipher?: {
+        name?: string;
+        standardName?: string;
+        version?: string;
+    } | null;
+};
+type NetSocketHandle = {
+    setNoDelay?: (enable?: boolean) => unknown;
+    setKeepAlive?: (enable?: boolean, initialDelay?: number) => unknown;
+    readStart?: () => unknown;
+    ref?: () => unknown;
+    unref?: () => unknown;
+    socketId?: number;
+};
+type AcceptedNetClientHandle = NetSocketHandle & {
+    socketId: number;
+    info: NetSocketInfo;
+};
+declare class NetSocket {
+    private _listeners;
+    private _onceListeners;
+    private _socketId;
+    private _loopbackServer;
+    private _loopbackBuffer;
+    private _loopbackDispatchRunning;
+    private _loopbackReadableEnded;
+    private _loopbackEventQueue;
+    private _encoding?;
+    private _noDelayState;
+    private _keepAliveState;
+    private _keepAliveDelaySeconds;
+    private _refed;
+    private _bridgeReadLoopRunning;
+    private _bridgeReadPollTimer;
+    private _timeoutMs;
+    private _timeoutTimer;
+    private _tlsUpgrading;
+    _connected: boolean;
+    connecting: boolean;
+    destroyed: boolean;
+    writable: boolean;
+    readable: boolean;
+    readableLength: number;
+    writableLength: number;
+    remoteAddress?: string;
+    remotePort?: number;
+    remoteFamily?: string;
+    localAddress: string;
+    localPort: number;
+    localFamily: string;
+    localPath?: string;
+    remotePath?: string;
+    bytesRead: number;
+    bytesWritten: number;
+    bufferSize: number;
+    pending: boolean;
+    allowHalfOpen: boolean;
+    encrypted: boolean;
+    authorized: boolean;
+    authorizationError?: string;
+    servername?: string;
+    alpnProtocol: string | false;
+    writableHighWaterMark: number;
+    server?: NetServer;
+    _tlsCipher: SerializedTlsState["cipher"];
+    _tlsProtocol: string | null;
+    _tlsSession: Buffer | null;
+    _tlsSessionReused: boolean;
+    _readableState: {
+        endEmitted: boolean;
+    };
+    _handle: NetSocketHandle | null;
+    constructor(options?: {
+        allowHalfOpen?: boolean;
+        handle?: NetSocketHandle | null;
+    });
+    connect(portOrOptions: number | string | {
+        host?: string;
+        port?: number;
+        path?: string;
+        keepAlive?: unknown;
+        keepAliveInitialDelay?: number;
+    }, hostOrCallback?: string | (() => void), callback?: () => void): this;
+    write(data: unknown, encodingOrCallback?: string | (() => void), callback?: () => void): boolean;
+    end(dataOrCallback?: unknown, encodingOrCallback?: string | (() => void), callback?: () => void): this;
+    destroy(error?: Error): this;
+    _applySocketInfo(info: NetSocketInfo | null): void;
+    _applyAcceptedKeepAlive(initialDelay?: number): void;
+    static fromAcceptedHandle(handle: AcceptedNetClientHandle, options?: {
+        allowHalfOpen?: boolean;
+    }): NetSocket;
+    setKeepAlive(enable?: boolean, initialDelay?: number): this;
+    setNoDelay(noDelay?: boolean): this;
+    setTimeout(timeout: number, callback?: () => void): this;
+    ref(): this;
+    unref(): this;
+    pause(): this;
+    resume(): this;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    };
+    getCipher(): SerializedTlsState["cipher"];
+    getSession(): Buffer | null;
+    isSessionReused(): boolean;
+    getPeerCertificate(detailed?: boolean): Record<string, unknown>;
+    getCertificate(): Record<string, unknown>;
+    getProtocol(): string | null;
+    setEncoding(encoding: string): this;
+    pipe<T>(destination: T): T;
+    on(event: string, listener: NetEventListener): this;
+    addListener(event: string, listener: NetEventListener): this;
+    once(event: string, listener: NetEventListener): this;
+    removeListener(event: string, listener: NetEventListener): this;
+    off(event: string, listener: NetEventListener): this;
+    removeAllListeners(event?: string): this;
+    listeners(event: string): NetEventListener[];
+    listenerCount(event: string): number;
+    setMaxListeners(_n: number): this;
+    getMaxListeners(): number;
+    prependListener(event: string, listener: NetEventListener): this;
+    prependOnceListener(event: string, listener: NetEventListener): this;
+    eventNames(): string[];
+    rawListeners(event: string): NetEventListener[];
+    emit(event: string, ...args: unknown[]): boolean;
+    _emitNet(event: string, ...args: unknown[]): boolean;
+    private _waitForConnect;
+    private _pumpBridgeReads;
+    private _dispatchLoopbackHttpRequest;
+    private _processLoopbackHttpRequests;
+    private _pushLoopbackData;
+    private _closeLoopbackReadable;
+    private _queueLoopbackEvent;
+    private _dispatchLoopbackUpgrade;
+    _upgradeTls(options?: SerializedTlsBridgeOptions): void;
+    _touchTimeout(): void;
+    _clearTimeoutTimer(): void;
+}
+declare function netConnect(portOrOptions: number | string | {
+    host?: string;
+    port?: number;
+    path?: string;
+    keepAlive?: unknown;
+    keepAliveInitialDelay?: number;
+}, hostOrCallback?: string | (() => void), callback?: () => void): NetSocket;
+type NetServerEventListener = (...args: unknown[]) => void;
+declare class NetServer {
+    private _listeners;
+    private _onceListeners;
+    private _serverId;
+    private _address;
+    private _acceptLoopActive;
+    private _acceptLoopRunning;
+    private _acceptPollTimer;
+    private _handleRefId;
+    private _connections;
+    private _refed;
+    listening: boolean;
+    keepAlive: boolean;
+    keepAliveInitialDelay: number;
+    allowHalfOpen: boolean;
+    maxConnections?: number;
+    _handle: {
+        onconnection: (err: Error | null, clientHandle?: AcceptedNetClientHandle) => void;
+    };
+    constructor(optionsOrListener?: {
+        allowHalfOpen?: boolean;
+        keepAlive?: boolean;
+        keepAliveInitialDelay?: number;
+    } | NetServerEventListener, maybeListener?: NetServerEventListener);
+    listen(portOrOptions?: number | string | null | {
+        port?: unknown;
+        host?: unknown;
+        backlog?: unknown;
+        path?: unknown;
+    }, hostOrCallback?: string | NetServerEventListener, backlogOrCallback?: number | NetServerEventListener, callback?: NetServerEventListener): this;
+    close(callback?: NetServerEventListener): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | string | null;
+    getConnections(callback: (error: Error | null, count: number) => void): this;
+    ref(): this;
+    unref(): this;
+    on(event: string, listener: NetServerEventListener): this;
+    once(event: string, listener: NetServerEventListener): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    private _emit;
+    private _syncHandleRef;
+    private _pumpAccepts;
+}
+type TlsConnectOptions = {
+    host?: string;
+    port?: number;
+    socket?: NetSocket;
+    rejectUnauthorized?: boolean;
+    servername?: string;
+    session?: Buffer | Uint8Array;
+    ALPNProtocols?: string[];
+    secureContext?: TlsSecureContextWrapper;
+    key?: unknown;
+    cert?: unknown;
+    ca?: unknown;
+    ciphers?: string;
+    minVersion?: string;
+    maxVersion?: string;
+    passphrase?: string;
+};
+type TlsServerOptions = {
+    allowHalfOpen?: boolean;
+    keepAlive?: boolean;
+    keepAliveInitialDelay?: number;
+    rejectUnauthorized?: boolean;
+    requestCert?: boolean;
+    SNICallback?: (servername: string, callback: (error: Error | null, context: unknown) => void) => void;
+    ALPNProtocols?: string[];
+    ALPNCallback?: (info: {
+        servername?: string;
+        protocols: string[];
+    }) => string | undefined;
+    secureContext?: TlsSecureContextWrapper;
+    key?: unknown;
+    cert?: unknown;
+    ca?: unknown;
+    ciphers?: string;
+    minVersion?: string;
+    maxVersion?: string;
+    passphrase?: string;
+};
+declare function tlsConnect(portOrOptions: number | TlsConnectOptions, hostOrCallback?: string | (() => void), callback?: () => void): NetSocket;
+declare class TLSServer {
+    private _listeners;
+    private _onceListeners;
+    private _server;
+    private _tlsOptions;
+    private _sniCallback?;
+    private _alpnCallback?;
+    private _contexts;
+    constructor(optionsOrListener?: TlsServerOptions | NetServerEventListener, maybeListener?: NetServerEventListener);
+    listen(portOrOptions?: number | string | null | {
+        port?: unknown;
+        host?: unknown;
+        backlog?: unknown;
+        path?: unknown;
+    }, hostOrCallback?: string | NetServerEventListener, backlogOrCallback?: number | NetServerEventListener, callback?: NetServerEventListener): this;
+    close(callback?: NetServerEventListener): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    } | string | null;
+    getConnections(callback: (error: Error | null, count: number) => void): this;
+    ref(): this;
+    unref(): this;
+    addContext(servername: string, context: unknown): this;
+    on(event: string, listener: NetServerEventListener): this;
+    once(event: string, listener: NetServerEventListener): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    private _emit;
+    private _handleSecureSocket;
+    private _getClientHello;
+    private _resolveTlsOptions;
+    private _findContext;
+    private _emitTlsClientError;
+}
+type DgramEventListener = (...args: unknown[]) => void;
+type DgramSocketAddress = {
+    address: string;
+    family: string;
+    port: number;
+};
+declare class DgramSocket {
+    private readonly _type;
+    private readonly _socketId;
+    private _listeners;
+    private _onceListeners;
+    private _bindPromise;
+    private _receiveLoopRunning;
+    private _receivePollTimer;
+    private _refed;
+    private _closed;
+    private _bound;
+    private _handleRefId;
+    private _recvBufferSize?;
+    private _sendBufferSize?;
+    private _memberships;
+    private _multicastInterface?;
+    private _broadcast;
+    private _multicastLoopback;
+    private _multicastTtl;
+    private _ttl;
+    constructor(optionsOrType: unknown, listener?: DgramEventListener);
+    bind(...args: unknown[]): this;
+    send(...args: unknown[]): void;
+    sendto(...args: unknown[]): void;
+    address(): DgramSocketAddress;
+    close(callback?: () => void): this;
+    ref(): this;
+    unref(): this;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    setBroadcast(flag: unknown): void;
+    setTTL(ttl: unknown): number;
+    setMulticastTTL(ttl: unknown): number;
+    setMulticastLoopback(flag: unknown): number;
+    addMembership(multicastAddress?: unknown, multicastInterface?: unknown): void;
+    dropMembership(multicastAddress?: unknown, multicastInterface?: unknown): void;
+    addSourceSpecificMembership(sourceAddress?: unknown, groupAddress?: unknown, multicastInterface?: unknown): void;
+    dropSourceSpecificMembership(sourceAddress?: unknown, groupAddress?: unknown, multicastInterface?: unknown): void;
+    setMulticastInterface(interfaceAddress: unknown): void;
+    on(event: string, listener: DgramEventListener): this;
+    addListener(event: string, listener: DgramEventListener): this;
+    once(event: string, listener: DgramEventListener): this;
+    removeListener(event: string, listener: DgramEventListener): this;
+    off(event: string, listener: DgramEventListener): this;
+    emit(event: string, ...args: unknown[]): boolean;
+    private _bindInternal;
+    private _ensureBound;
+    private _sendInternal;
+    private _pumpMessages;
+    private _clearReceivePollTimer;
+    private _ensureBoundForSocketOption;
+    private _setBufferSize;
+    private _getBufferSize;
+    private _applyInitialBufferSizes;
+    private _syncHandleRef;
+    private _emit;
+}
+declare const _default: {
+    fetch: typeof fetch;
+    Headers: typeof Headers;
+    Request: typeof Request;
+    Response: typeof Response;
+    dns: {
+        lookup(hostname: string, options: unknown, callback?: DnsCallback): void;
+        resolve(hostname: string, rrtype: string | DnsResolveCallback, callback?: DnsResolveCallback): void;
+        resolve4(hostname: string, callback: DnsResolveCallback): void;
+        resolve6(hostname: string, callback: DnsResolveCallback): void;
+        promises: {
+            lookup(hostname: string, _options?: unknown): Promise<{
+                address: string;
+                family: number;
+            }>;
+            resolve(hostname: string, rrtype?: string): Promise<string[]>;
+        };
+    };
+    http: Record<string, unknown>;
+    https: Record<string, unknown>;
+    http2: {
+        Http2ServerRequest: typeof Http2ServerRequest;
+        Http2ServerResponse: typeof Http2ServerResponse;
+        constants: Record<string, string | number>;
+        getDefaultSettings(): Http2SettingsRecord;
+        connect: typeof connectHttp2;
+        createServer: (optionsOrListener?: Record<string, unknown> | ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined, maybeListener?: ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined) => Http2Server;
+        createSecureServer: (optionsOrListener?: Record<string, unknown> | ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined, maybeListener?: ((req: Http2ServerRequest, res: Http2ServerResponse) => void) | undefined) => Http2Server;
+    };
+    IncomingMessage: typeof IncomingMessage;
+    ClientRequest: typeof ClientRequest;
+    net: {
+        Socket: typeof NetSocket;
+        Server: typeof import("node:net").Server;
+        connect: typeof netConnect;
+        createConnection: typeof netConnect;
+        createServer(optionsOrListener?: {
+            allowHalfOpen?: boolean;
+            keepAlive?: boolean;
+            keepAliveInitialDelay?: number;
+        } | NetServerEventListener, maybeListener?: NetServerEventListener): NetServer;
+        isIP(input: string): number;
+        isIPv4(input: string): boolean;
+        isIPv6(input: string): boolean;
+    };
+    tls: {
+        connect: typeof tlsConnect;
+        TLSSocket: typeof NetSocket;
+        Server: typeof import("node:tls").Server;
+        createServer(optionsOrListener?: TlsServerOptions | NetServerEventListener, maybeListener?: NetServerEventListener): TLSServer;
+        createSecureContext(options?: Record<string, unknown>): TlsSecureContextWrapper;
+        getCiphers(): string[];
+        DEFAULT_MIN_VERSION: string;
+        DEFAULT_MAX_VERSION: string;
+    };
+    dgram: {
+        Socket: typeof nodeDgram.Socket;
+        createSocket(optionsOrType: unknown, callback?: DgramEventListener): DgramSocket;
+    };
+};
+export default _default;