@fkn/lib 0.5.5 → 0.6.1

package/http.d.ts

@@ -1,767 +1,186 @@
-import { OutgoingHttpHeaders, IncomingHttpHeaders, RequestOptions } from 'http';
-import { Stream, DuplexOptions } from 'stream';
-import { Buffer } from 'buffer';
-import * as ip_address from 'ip-address';
-import { Address4, Address6 } from 'ip-address';
-import { Socket as Socket$1, SocketConstructorOpts, SocketConnectOpts, AddressInfo, Server as Server$2, ServerOpts, ListenOptions } from 'net';
-import { EventEmitter } from 'events';
+import { n as Socket, t as Server$1 } from "./net-BDW1AVX1.js";
+import { Buffer } from "buffer";
+import { Stream } from "stream";
+import { IncomingHttpHeaders, OutgoingHttpHeaders, RequestOptions } from "http";
 
-declare const parseServerMetadataTcpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketConnectedPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: ip_address.Address4 | ip_address.Address6;
-    readonly localPort: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: ip_address.Address4 | ip_address.Address6;
-    readonly remotePort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-type ServerMetadataTcpSocketConnectedPacket = ReturnType<typeof parseServerMetadataTcpSocketConnectedPacket>;
-declare const parseServerMetadataTcpSocketShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketShutdownPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-type ServerMetadataTcpSocketShutdownPacket = ReturnType<typeof parseServerMetadataTcpSocketShutdownPacket>;
-declare const TCP_OPTION_NODELAY: 0;
-declare const TCP_OPTION_TTL: 1;
-declare const TCP_OPTION_KEEPALIVE: 2;
-declare const TCP_OPTION_SEND_BUFFER_SIZE: 3;
-declare const TCP_OPTION_RECV_BUFFER_SIZE: 4;
-type TcpSocketOption = {
-    type: typeof TCP_OPTION_NODELAY;
-    value: boolean;
-} | {
-    type: typeof TCP_OPTION_TTL;
-    value: number;
-} | {
-    type: typeof TCP_OPTION_KEEPALIVE;
-    enabled: boolean;
-    initialDelaySeconds: number;
-} | {
-    type: typeof TCP_OPTION_SEND_BUFFER_SIZE;
-    value: number;
-} | {
-    type: typeof TCP_OPTION_RECV_BUFFER_SIZE;
-    value: number;
-};
-declare const parseServerMetadataTcpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ServerMetadataTcpSetOptionAckPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    errorLength: number;
-    error: string;
-};
-type ServerMetadataTcpSetOptionAckPacket = ReturnType<typeof parseServerMetadataTcpSetOptionAckPacket>;
-
-declare const parseServerMetadataTcpSocketListenerBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketListenerBoundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: ip_address.Address4 | ip_address.Address6;
-    readonly localPort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-type ServerMetadataTcpSocketListenerBoundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerBoundPacket>;
-declare const parseServerMetadataTcpSocketListenerUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataTcpSocketListenerUnboundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-type ServerMetadataTcpSocketListenerUnboundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerUnboundPacket>;
-
-declare const parseServerMetadataUdpSocketBoundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketBoundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: ip_address.Address4 | ip_address.Address6;
-    readonly localPort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-type ServerMetadataUdpSocketBoundPacket = ReturnType<typeof parseServerMetadataUdpSocketBoundPacket>;
-declare const parseServerMetadataUdpSocketUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketUnboundPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-type ServerMetadataUdpSocketUnboundPacket = ReturnType<typeof parseServerMetadataUdpSocketUnboundPacket>;
-declare const parseServerMetadataUdpSocketConnectedPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataUdpSocketConnectedPacket";
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: ip_address.Address4 | ip_address.Address6;
-    readonly remotePort: number;
-    readonly errorLength: number;
-    readonly error: string;
-};
-type ServerMetadataUdpSocketConnectedPacket = ReturnType<typeof parseServerMetadataUdpSocketConnectedPacket>;
-declare const UDP_OPTION_BROADCAST: 0;
-declare const UDP_OPTION_TTL: 1;
-declare const UDP_OPTION_MULTICAST_TTL_V4: 2;
-declare const UDP_OPTION_MULTICAST_LOOP_V4: 3;
-declare const UDP_OPTION_MULTICAST_LOOP_V6: 4;
-declare const UDP_OPTION_ADD_MEMBERSHIP_V4: 5;
-declare const UDP_OPTION_DROP_MEMBERSHIP_V4: 6;
-declare const UDP_OPTION_ADD_MEMBERSHIP_V6: 7;
-declare const UDP_OPTION_DROP_MEMBERSHIP_V6: 8;
-declare const UDP_OPTION_SEND_BUFFER_SIZE: 9;
-declare const UDP_OPTION_RECV_BUFFER_SIZE: 10;
-type UdpSocketOption = {
-    type: typeof UDP_OPTION_BROADCAST;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_TTL;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_TTL_V4;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_LOOP_V4;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_MULTICAST_LOOP_V6;
-    value: boolean;
-} | {
-    type: typeof UDP_OPTION_ADD_MEMBERSHIP_V4;
-    group: Uint8Array;
-    interface: Uint8Array;
-} | {
-    type: typeof UDP_OPTION_DROP_MEMBERSHIP_V4;
-    group: Uint8Array;
-    interface: Uint8Array;
-} | {
-    type: typeof UDP_OPTION_ADD_MEMBERSHIP_V6;
-    group: Uint8Array;
-    ifIndex: number;
-} | {
-    type: typeof UDP_OPTION_DROP_MEMBERSHIP_V6;
-    group: Uint8Array;
-    ifIndex: number;
-} | {
-    type: typeof UDP_OPTION_SEND_BUFFER_SIZE;
-    value: number;
-} | {
-    type: typeof UDP_OPTION_RECV_BUFFER_SIZE;
-    value: number;
-};
-declare const parseServerMetadataUdpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: "ServerMetadataUdpSetOptionAckPacket";
-    offset: number;
-    id: number;
-    socketId: number;
-    errorLength: number;
-    error: string;
-};
-type ServerMetadataUdpSetOptionAckPacket = ReturnType<typeof parseServerMetadataUdpSetOptionAckPacket>;
-
-declare const parseServerMetadataHeaderPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: "ServerMetadataHeaderPacket";
-    readonly offset: number;
-    readonly agentLength: number;
-    readonly agent: string;
-    readonly versionLength: number;
-    readonly version: string;
-};
-type ServerMetadataHeaderPacket = ReturnType<typeof parseServerMetadataHeaderPacket>;
-type ServerMetadataPacket = ServerMetadataHeaderPacket | ServerMetadataTcpSocketConnectedPacket | ServerMetadataTcpSocketShutdownPacket | ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket | ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketUnboundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataTcpSetOptionAckPacket | ServerMetadataUdpSetOptionAckPacket;
-
-type BidirectionalStreams = {
-    readable: ReadableStream<Uint8Array>;
-    writable: WritableStream<Uint8Array>;
-};
-declare const makeWebVPNWebTransport: () => Promise<{
-    webtransport: WebTransport;
-    isClosed: () => boolean;
-    getNewPacketId: () => number;
-    getTcpDataReadableStreamForSocketId: (socketId: number, options?: {
-        signal?: AbortSignal;
-    }) => Promise<BidirectionalStreams>;
-    getUdpDataReadableStreamForSocketId: (socketId: number) => ReadableStream<{
-        readonly _type: "ServerUdpDataPacket";
-        readonly offset: number;
-        readonly socketId: number;
-        readonly remoteAddressType: 0 | 1 | 2;
-        readonly remoteAddress: Address4 | Address6 | undefined;
-        readonly remotePort: number | undefined;
-        readonly dataLength: number;
-        readonly data: ArrayBuffer;
-    }>;
-    claimUdpRawStream: (socketId: number, sink: (packetBytes: Uint8Array) => void) => void;
-    releaseUdpRawStream: (socketId: number) => void;
-    getPacketForId: (packetId: number) => Promise<ServerMetadataPacket>;
-    getMetadataReadableStreamForSocketId: (socketId: number) => ReadableStream<ServerMetadataPacket>;
-    getMetadataReadableStreamForLocalAddress: (address: Address4 | Address6) => ReadableStream<ServerMetadataPacket>;
-    getMetadataReadableStreamForLocalPort: (port: number) => ReadableStream<ServerMetadataPacket>;
-    getMetadataWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
-    getDatagramWritableStream: () => WritableStream<Uint8Array<ArrayBufferLike>>;
-    presentRateToken: () => Promise<void>;
-}>;
-type WebVPNWebTransport = Awaited<ReturnType<typeof makeWebVPNWebTransport>>;
-
-declare const processTcpSocket: ({ connectedPacket, dataReadableStream, dataWritableStream, metadataReadableStream, metadataWriter, dataStreamAbort, webVpnWebTransport }: {
-    connectedPacket: ServerMetadataTcpSocketConnectedPacket;
-    dataReadableStream: ReadableStream<Uint8Array>;
-    dataWritableStream: WritableStream<Uint8Array>;
-    metadataReadableStream: ReadableStream<ServerMetadataPacket>;
-    metadataWriter: WritableStreamDefaultWriter<Uint8Array>;
-    dataStreamAbort?: AbortController;
-    webVpnWebTransport: WebVPNWebTransport;
-}) => Promise<{
-    localAddress: string;
-    localFamily: "IPv4" | "IPv6";
-    localPort: number;
-    remoteAddress: string;
-    remoteFamily: "IPv4" | "IPv6";
-    remotePort: number;
-    dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-    dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-    end: () => Promise<void>;
-    destroy: () => Promise<void>;
-    destroySoon: () => Promise<void>;
-    resetAndDestroy: () => Promise<void>;
-    setOption: (option: TcpSocketOption) => Promise<void>;
-}>;
-type TcpSocketResult = Awaited<ReturnType<typeof processTcpSocket>>;
-
-type StorageEntry = {
-    path: string;
-    size: number;
-    contentType: string | null;
-    updatedAt: string;
-};
-type StorageQuota = {
-    usedBytes: number;
-    limitBytes: number;
-    remaining: number;
-    objects: number;
-    maxObjects: number;
-};
-type WriteData = ArrayBuffer | Uint8Array | string;
-
-type Account = {
-    name: string;
-    image: string | null;
-    premium: boolean;
-    premiumUntil: string | null;
-};
-
-type AddressLookupResult = {
-    address: string;
-    family: 0 | 4 | 6;
-};
-
-type Quota = {
-    overQuota: boolean;
-    remaining: number;
-    usedBytes: number;
-    limitBytes: number;
-    premium: boolean;
-    bytesPerSecond: number;
-};
-
-declare const resolvers: {
-    readonly cloud: {
-        readonly fetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
-            render?: boolean;
-        }) => Promise<Response>;
-        readonly quota: () => Promise<Quota>;
-        readonly dns: {
-            readonly lookup: <T extends boolean = false>(hostname: string, options?: {
-                all?: T;
-                family?: 0 | 4 | 6;
-            }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
-        };
-        readonly fs: {
-            readonly available: () => Promise<boolean>;
-            readonly list: () => Promise<StorageEntry[]>;
-            readonly quota: () => Promise<StorageQuota>;
-            readonly readFile: (path: string) => Promise<Uint8Array>;
-            readonly writeFile: (path: string, data: WriteData, contentType: string | null) => Promise<void>;
-            readonly remove: (path: string) => Promise<void>;
-        };
-        readonly webvpn: {
-            readonly tcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
-                remoteAddress: string;
-                remotePort: number;
-            }) => Promise<{
-                localAddress: string;
-                localFamily: "IPv4" | "IPv6";
-                localPort: number;
-                remoteAddress: string;
-                remoteFamily: "IPv4" | "IPv6";
-                remotePort: number;
-                dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-                dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-                end: () => Promise<void>;
-                destroy: () => Promise<void>;
-                destroySoon: () => Promise<void>;
-                resetAndDestroy: () => Promise<void>;
-                setOption: (option: TcpSocketOption) => Promise<void>;
-            }>;
-            readonly tcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
-                localAddress: string;
-                localPort: number;
-                onConnection: (connection: TcpSocketResult) => void;
-            }) => Promise<{
-                localAddress: string;
-                localFamily: "IPv4" | "IPv6";
-                localPort: number;
-                close: () => Promise<void>;
-            }>;
-            readonly udpSocket: ({ type, port, address, dataPort }: {
-                type: "udp4" | "udp6";
-                port: number;
-                address: string;
-                dataPort?: boolean;
-            }) => Promise<{
-                socketId: number;
-                dataPort: MessagePort | undefined;
-                localAddress: string;
-                localFamily: "IPv4" | "IPv6";
-                localPort: number;
-                dataReadableStream: ReadableStream<{
-                    data: ArrayBuffer;
-                    size: number;
-                    family: "IPv4" | "IPv6";
-                    address: string;
-                    port: number;
-                }>;
-                connect: ({ remoteAddress: _remoteAddress, remotePort }: {
-                    remoteAddress: string;
-                    remotePort: number;
-                }) => Promise<void>;
-                send: ({ message, address: _remoteAddress, port: remotePort }: {
-                    message: ArrayBuffer;
-                    address?: string;
-                    port?: number;
-                }) => Promise<void>;
-                close: () => Promise<void>;
-                setOption: (option: UdpSocketOption) => Promise<void>;
-            }>;
-        };
-    };
-    readonly overlay: {
-        readonly setHost: (push: (state: {
-            modal: boolean;
-            rects: {
-                x: number;
-                y: number;
-                width: number;
-                height: number;
-            }[];
-        }) => unknown) => void;
-    };
-    readonly installPrompt: {
-        readonly show: (reason?: string) => Promise<void>;
-        readonly hide: () => void;
-    };
-    readonly connect: {
-        readonly prompt: (consumerOrigin: string) => Promise<boolean>;
-    };
-    readonly account: {
-        readonly info: () => Promise<Account | null>;
-        readonly login: (consumerOrigin: string) => Promise<boolean>;
-        readonly logout: () => void;
-        readonly onChange: (listener: () => void) => (() => void);
-    };
-    readonly proxyFetch: (input: string | URL | Request, init?: (RequestInit | undefined) & {
-        render?: boolean;
-    }) => Promise<Response>;
-    readonly webVpnTcpSocket: ({ remoteAddress: _remoteAddress, remotePort }: {
-        remoteAddress: string;
-        remotePort: number;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        remoteAddress: string;
-        remoteFamily: "IPv4" | "IPv6";
-        remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-        end: () => Promise<void>;
-        destroy: () => Promise<void>;
-        destroySoon: () => Promise<void>;
-        resetAndDestroy: () => Promise<void>;
-        setOption: (option: TcpSocketOption) => Promise<void>;
-    }>;
-    readonly webVpnTcpSocketListener: ({ localAddress: _localAddress, localPort, onConnection }: {
-        localAddress: string;
-        localPort: number;
-        onConnection: (connection: TcpSocketResult) => void;
-    }) => Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        close: () => Promise<void>;
-    }>;
-    readonly webVpnUdpSocket: ({ type, port, address, dataPort }: {
-        type: "udp4" | "udp6";
-        port: number;
-        address: string;
-        dataPort?: boolean;
-    }) => Promise<{
-        socketId: number;
-        dataPort: MessagePort | undefined;
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        dataReadableStream: ReadableStream<{
-            data: ArrayBuffer;
-            size: number;
-            family: "IPv4" | "IPv6";
-            address: string;
-            port: number;
-        }>;
-        connect: ({ remoteAddress: _remoteAddress, remotePort }: {
-            remoteAddress: string;
-            remotePort: number;
-        }) => Promise<void>;
-        send: ({ message, address: _remoteAddress, port: remotePort }: {
-            message: ArrayBuffer;
-            address?: string;
-            port?: number;
-        }) => Promise<void>;
-        close: () => Promise<void>;
-        setOption: (option: UdpSocketOption) => Promise<void>;
-    }>;
-    readonly dnsLookup: <T extends boolean = false>(hostname: string, options?: {
-        all?: T;
-        family?: 0 | 4 | 6;
-    }) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
-    readonly setOverlayHost: (push: (state: {
-        modal: boolean;
-        rects: {
-            x: number;
-            y: number;
-            width: number;
-            height: number;
-        }[];
-    }) => unknown) => void;
-    readonly showInstallPrompt: (reason?: string) => Promise<void>;
-    readonly hideInstallPrompt: () => void;
-};
-type Resolvers = typeof resolvers;
-
-type WebVpnTcpSocket = Resolvers['cloud']['webvpn']['tcpSocket'];
-type WebVpnTcpSocketListener = Resolvers['cloud']['webvpn']['tcpSocketListener'];
-
-declare class Socket extends Stream.Duplex implements Socket$1 {
-    _localAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _remoteAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _webVPNTcpSocketPromise?: Promise<(Awaited<ReturnType<WebVpnTcpSocket>> & {
-        reader: ReadableStreamDefaultReader<Uint8Array>;
-        writer: WritableStreamDefaultWriter<Uint8Array>;
-    }) | undefined>;
-    constructor(options?: SocketConstructorOpts & DuplexOptions & {
-        connection?: ReturnType<WebVpnTcpSocket>;
-    });
-    __webvpn_tcp_socket_init__(connection: ReturnType<WebVpnTcpSocket>): Promise<({
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        remoteAddress: string;
-        remoteFamily: "IPv4" | "IPv6";
-        remotePort: number;
-        dataReadableStream: ReadableStream<Uint8Array<ArrayBufferLike>>;
-        dataWritableStream: WritableStream<Uint8Array<ArrayBufferLike>>;
-        end: () => Promise<void>;
-        destroy: () => Promise<void>;
-        destroySoon: () => Promise<void>;
-        resetAndDestroy: () => Promise<void>;
-        setOption: (option: TcpSocketOption) => Promise<void>;
-    } & {
-        reader: ReadableStreamDefaultReader<Uint8Array>;
-        writer: WritableStreamDefaultWriter<Uint8Array>;
-    }) | undefined>;
-    /** STREAM IMPL */
-    _read(size: number): void;
-    _write(chunk: Uint8Array, encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    /** SOCKET IMPL */
-    connect(options: SocketConnectOpts, connectionListener?: (() => void) | undefined): this;
-    connect(port: number, host: string, connectionListener?: (() => void) | undefined): this;
-    connect(port: number, connectionListener?: (() => void) | undefined): this;
-    connect(path: string, connectionListener?: (() => void) | undefined): this;
-    connect(port: unknown, host?: unknown, connectionListener?: unknown): this;
-    _end(chunk: any, cb?: () => void): this;
-    _end(chunk: any, encoding?: BufferEncoding, cb?: () => void): this;
-    _destroy(error?: Error | null | undefined): this;
-    destroySoon(): void;
-    resetAndDestroy(): this;
-    _timeoutMs?: number;
-    _timeoutTimer?: ReturnType<typeof setTimeout>;
-    _restartTimeoutTimer(): void;
-    setTimeout(timeout: number, callback?: (() => void) | undefined): this;
-    setNoDelay(noDelay?: boolean | undefined): this;
-    setKeepAlive(enable?: boolean | undefined, initialDelay?: number | undefined): this;
-    setSendBufferSize(size: number): this;
-    setRecvBufferSize(size: number): this;
-    _typeOfService?: number;
-    getTypeOfService(): number;
-    setTypeOfService(tos: number): this;
-    _setTcpOption(option: TcpSocketOption): void;
-    write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
-    write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
-    address(): AddressInfo | {};
-    unref(): this;
-    ref(): this;
-    autoSelectFamilyAttemptedAddresses: string[];
-    bufferSize: number;
-    bytesRead: number;
-    bytesWritten: number;
-    connecting: boolean;
-    pending: boolean;
-    get localAddress(): string;
-    get localPort(): number;
-    get localFamily(): string;
-    readyState: 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
-    get remoteAddress(): string;
-    get remotePort(): number;
-    get remoteFamily(): string;
-    timeout?: number | undefined;
-}
-interface EventEmitterOptions {
-    /**
-     * Enables automatic capturing of promise rejection.
-     */
-    captureRejections?: boolean | undefined;
+//#region src/lib/webvpn/http.d.ts
+declare namespace http_d_exports {
+  export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, createServer, _default as default, get, globalAgent, request };
 }
-declare class Server$1 extends EventEmitter implements Server$2 {
-    _localAddress?: {
-        address: string;
-        family: string;
-        port: number;
-    };
-    _webVPNTcpSocketListenerPromise?: Promise<Awaited<ReturnType<WebVpnTcpSocketListener>> | undefined>;
-    constructor(options?: ServerOpts & EventEmitterOptions & {
-        connection?: ReturnType<WebVpnTcpSocketListener>;
-    }, connectionListener?: (socket: Socket) => void);
-    __webvpn_tcp_socket_listener_init__(connection: ReturnType<WebVpnTcpSocketListener>): Promise<{
-        localAddress: string;
-        localFamily: "IPv4" | "IPv6";
-        localPort: number;
-        close: () => Promise<void>;
-    } | undefined>;
-    listen(port?: number | undefined, hostname?: string | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, hostname?: string | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(port?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(path: string, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(path: string, listeningListener?: (() => void) | undefined): this;
-    listen(options: ListenOptions, listeningListener?: (() => void) | undefined): this;
-    listen(handle: any, backlog?: number | undefined, listeningListener?: (() => void) | undefined): this;
-    listen(handle: any, listeningListener?: (() => void) | undefined): this;
-    listen(port?: unknown, hostname?: unknown, backlog?: unknown, listeningListener?: unknown): this;
-    close(callback?: ((err?: Error | undefined) => void) | undefined): this;
-    address(): string | AddressInfo | null;
-    getConnections(cb: (error: Error | null, count: number) => void): this;
-    ref(): this;
-    unref(): this;
-    maxConnections: number;
-    connections: number;
-    listening: boolean;
-    [Symbol.asyncDispose](): Promise<void>;
-}
-
 declare const METHODS: string[];
 declare const STATUS_CODES: Record<number, string>;
 interface ParsedHead {
-    /** request only */
-    method?: string;
-    /** request only */
-    url?: string;
-    /** response only */
-    statusCode?: number;
-    /** response only */
-    statusMessage?: string;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    httpVersion: string;
-    headers: IncomingHttpHeaders;
-    rawHeaders: string[];
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  httpVersion: string;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
 }
 interface ParserHandlers {
-    onHeaders: (head: ParsedHead) => void;
-    onBody: (chunk: Uint8Array) => void;
-    onComplete: () => void;
+  onHeaders: (head: ParsedHead) => void;
+  onBody: (chunk: Uint8Array) => void;
+  onComplete: () => void;
 }
 declare class HTTPParser {
-    private readonly mode;
-    private readonly handlers;
-    private buf;
-    private state;
-    private framing;
-    private bodyRemaining;
-    private chunkState;
-    skipBody: boolean;
-    constructor(mode: 'request' | 'response', handlers: ParserHandlers);
-    execute(chunk: Uint8Array): void;
-    finish(): void;
-    private reset;
-    private parseHead;
-    private applyVersion;
-    private addHeader;
-    private setupBody;
-    private consumeBody;
-    private consumeChunked;
+  private readonly mode;
+  private readonly handlers;
+  private buf;
+  private state;
+  private framing;
+  private bodyRemaining;
+  private chunkState;
+  skipBody: boolean;
+  constructor(mode: 'request' | 'response', handlers: ParserHandlers);
+  execute(chunk: Uint8Array): void;
+  finish(): void;
+  private reset;
+  private parseHead;
+  private applyVersion;
+  private addHeader;
+  private setupBody;
+  private consumeBody;
+  private consumeChunked;
 }
 declare class IncomingMessage extends Stream.Readable {
-    httpVersion: string;
-    httpVersionMajor: number;
-    httpVersionMinor: number;
-    headers: IncomingHttpHeaders;
-    rawHeaders: string[];
-    trailers: Record<string, string>;
-    rawTrailers: string[];
-    /** request only */
-    method?: string;
-    /** request only */
-    url?: string;
-    /** response only */
-    statusCode?: number;
-    /** response only */
-    statusMessage?: string;
-    complete: boolean;
-    socket: Socket;
-    constructor(socket: Socket);
-    get connection(): Socket;
-    _applyHead(head: ParsedHead): void;
-    _read(): void;
-    setTimeout(msecs: number, callback?: () => void): this;
+  httpVersion: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  headers: IncomingHttpHeaders;
+  rawHeaders: string[];
+  trailers: Record<string, string>;
+  rawTrailers: string[];
+  /** request only */
+  method?: string;
+  /** request only */
+  url?: string;
+  /** response only */
+  statusCode?: number;
+  /** response only */
+  statusMessage?: string;
+  complete: boolean;
+  socket: Socket;
+  constructor(socket: Socket);
+  get connection(): Socket;
+  _applyHead(head: ParsedHead): void;
+  _read(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
 }
 declare abstract class OutgoingMessage extends Stream.Writable {
-    private _headerStore;
-    headersSent: boolean;
-    chunkedEncoding: boolean;
-    finished: boolean;
-    protected _bodyWritten: boolean;
-    abstract socket: Socket | null;
-    setHeader(name: string, value: number | string | readonly string[]): this;
-    getHeader(name: string): number | string | string[] | undefined;
-    getHeaderNames(): string[];
-    getHeaders(): OutgoingHttpHeaders;
-    hasHeader(name: string): boolean;
-    removeHeader(name: string): void;
-    protected _storeHeader(startLine: string): string;
-    protected abstract _shouldSendBody(): boolean;
-    protected abstract _implicitHeader(): void;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
-    write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
-    _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
-    _final(callback: (error?: Error | null) => void): void;
-    end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
-    protected _headBlock?: string;
+  private _headerStore;
+  headersSent: boolean;
+  chunkedEncoding: boolean;
+  finished: boolean;
+  protected _bodyWritten: boolean;
+  abstract socket: Socket | null;
+  setHeader(name: string, value: number | string | readonly string[]): this;
+  getHeader(name: string): number | string | string[] | undefined;
+  getHeaderNames(): string[];
+  getHeaders(): OutgoingHttpHeaders;
+  hasHeader(name: string): boolean;
+  removeHeader(name: string): void;
+  protected _storeHeader(startLine: string): string;
+  protected abstract _shouldSendBody(): boolean;
+  protected abstract _implicitHeader(): void;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  write(chunk: unknown, encoding?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
+  _write(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null) => void): void;
+  _final(callback: (error?: Error | null) => void): void;
+  end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
+  protected _headBlock?: string;
 }
 interface ServerResponseOptions {
-    req: IncomingMessage;
+  req: IncomingMessage;
 }
 declare class ServerResponse extends OutgoingMessage {
-    statusCode: number;
-    statusMessage?: string;
-    private _writeHeadCalled;
-    sendDate: boolean;
-    req: IncomingMessage;
-    socket: Socket | null;
-    _keepAlive: boolean;
-    constructor(req: IncomingMessage);
-    protected _shouldSendBody(): boolean;
-    writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
-    private _appendHeader;
-    protected _implicitHeader(): void;
-    writeContinue(): void;
-    setTimeout(msecs: number, callback?: () => void): this;
+  statusCode: number;
+  statusMessage?: string;
+  private _writeHeadCalled;
+  sendDate: boolean;
+  req: IncomingMessage;
+  socket: Socket | null;
+  _keepAlive: boolean;
+  constructor(req: IncomingMessage);
+  protected _shouldSendBody(): boolean;
+  writeHead(statusCode: number, statusMessage?: string | OutgoingHttpHeaders | OutgoingHttpHeaders[keyof OutgoingHttpHeaders][], headers?: OutgoingHttpHeaders): this;
+  private _appendHeader;
+  protected _implicitHeader(): void;
+  writeContinue(): void;
+  setTimeout(msecs: number, callback?: () => void): this;
 }
 interface ClientRequestArgs extends RequestOptions {
-    host?: string;
-    hostname?: string;
-    port?: number | string;
-    path?: string;
+  host?: string;
+  hostname?: string;
+  port?: number | string;
+  path?: string;
 }
 declare class ClientRequest extends OutgoingMessage {
-    method: string;
-    path: string;
-    host: string;
-    protocol: string;
-    socket: Socket;
-    /** alias retained for Node compatibility */
-    get connection(): Socket;
-    res: IncomingMessage | null;
-    aborted: boolean;
-    private _aborted;
-    constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
-    protected _shouldSendBody(): boolean;
-    protected _implicitHeader(): void;
-    private _attachResponseParser;
-    abort(): void;
-    destroy(error?: Error): this;
-    end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
-    protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
-    setTimeout(timeout: number, callback?: () => void): this;
-    setNoDelay(noDelay?: boolean): void;
-    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+  method: string;
+  path: string;
+  host: string;
+  protocol: string;
+  socket: Socket;
+  /** alias retained for Node compatibility */
+  get connection(): Socket;
+  res: IncomingMessage | null;
+  aborted: boolean;
+  private _aborted;
+  constructor(options: ClientRequestArgs, callback?: (res: IncomingMessage) => void);
+  protected _shouldSendBody(): boolean;
+  protected _implicitHeader(): void;
+  private _attachResponseParser;
+  abort(): void;
+  destroy(error?: Error): this;
+  end(chunk?: unknown, encoding?: unknown, callback?: unknown): this;
+  protected _writeToSocket(data: Buffer, callback: (error?: Error | null) => void): void;
+  setTimeout(timeout: number, callback?: () => void): this;
+  setNoDelay(noDelay?: boolean): void;
+  setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
 }
 type RequestListener = (req: IncomingMessage, res: ServerResponse) => void;
 declare class ServerImpl extends Server$1 {
-    constructor(options?: object | RequestListener, requestListener?: RequestListener);
-    private _handleConnection;
+  constructor(options?: object | RequestListener, requestListener?: RequestListener);
+  private _handleConnection;
 }
 declare const Server: typeof ServerImpl;
 type Server = ServerImpl;
 declare class Agent {
-    maxSockets: number;
-    maxFreeSockets: number;
-    keepAlive: boolean;
-    options: Record<string, unknown>;
-    constructor(options?: Record<string, unknown>);
-    getName(options?: {
-        host?: string;
-        port?: number;
-        localAddress?: string;
-    }): string;
-    destroy(): void;
+  maxSockets: number;
+  maxFreeSockets: number;
+  keepAlive: boolean;
+  options: Record<string, unknown>;
+  constructor(options?: Record<string, unknown>);
+  getName(options?: {
+    host?: string;
+    port?: number;
+    localAddress?: string;
+  }): string;
+  destroy(): void;
 }
 declare const globalAgent: Agent;
 declare const request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
 declare const get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
 declare const createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
 declare const _default: {
-    METHODS: string[];
-    STATUS_CODES: Record<number, string>;
-    Agent: typeof Agent;
-    globalAgent: Agent;
-    Server: typeof ServerImpl;
-    ServerResponse: typeof ServerResponse;
-    IncomingMessage: typeof IncomingMessage;
-    ClientRequest: typeof ClientRequest;
-    OutgoingMessage: typeof OutgoingMessage;
-    createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
-    request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
-    get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
-};
-
-export { Agent, ClientRequest, HTTPParser, IncomingMessage, METHODS, STATUS_CODES, Server, ServerResponse, _default, createServer, _default as default, get, globalAgent, request };
-export type { ClientRequestArgs, ParsedHead, RequestListener, ServerResponseOptions };
+  METHODS: string[];
+  STATUS_CODES: Record<number, string>;
+  Agent: typeof Agent;
+  globalAgent: Agent;
+  Server: typeof ServerImpl;
+  ServerResponse: typeof ServerResponse;
+  IncomingMessage: typeof IncomingMessage;
+  ClientRequest: typeof ClientRequest;
+  OutgoingMessage: typeof OutgoingMessage;
+  createServer: (options?: object | RequestListener, requestListener?: RequestListener) => Server;
+  request: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+  get: (...args: [options: string | URL | ClientRequestArgs, callback?: (res: IncomingMessage) => void] | [url: string | URL, options: ClientRequestArgs, callback?: (res: IncomingMessage) => void]) => ClientRequest;
+};
+//#endregion
+export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, _default as default, createServer, get, globalAgent, request, http_d_exports as t };