@fkn/lib 0.4.9 → 0.5.0

package/cloud.d.ts

@@ -0,0 +1,1048 @@
+import * as ip_address from 'ip-address';
+import { Address4, Address6 } from 'ip-address';
+import * as node_fs from 'node:fs';
+import { Socket as Socket$2, SocketConstructorOpts, SocketConnectOpts, AddressInfo, Server as Server$2, ServerOpts, ListenOptions } from 'net';
+import { Stream, DuplexOptions } from 'stream';
+import { EventEmitter } from 'events';
+import { Socket as Socket$3, SocketOptions, BindOptions, SocketType, RemoteInfo } from 'dgram';
+import { Buffer as Buffer$1 } from 'buffer';
+import { OutgoingHttpHeaders, IncomingHttpHeaders, RequestOptions } from 'http';
+
+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 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 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$1 = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+type WriteData$1 = Blob | 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$1>;
+            readonly readFile: (path: string) => Promise<Blob>;
+            readonly writeFile: (path: string, data: WriteData$1, 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 ProxyFetch = Resolvers['cloud']['fetch'];
+type FetchParameters = Parameters<ProxyFetch>;
+declare const cloudFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
+
+type QuotaStatus = {
+    /** the user has a paid subscription, throttle never applies */
+    premium: boolean;
+    /** today's free-tier volume is spent (true even for premium, see `throttled`) */
+    overQuota: boolean;
+    /** transfers are actually being rate-limited right now (overQuota and not premium) */
+    throttled: boolean;
+    /** bytes egressed through FKN relays today (per anonymized IP), saturates at limitBytes:
+     *  consumption past the free-tier volume is private and never reported */
+    usedBytes: number;
+    /** free-tier daily volume before throttling kicks in */
+    limitBytes: number;
+    /** bytes of free-tier volume left today */
+    remainingBytes: number;
+    /** current effective egress rate cap, bytes per second */
+    bytesPerSecond: number;
+    /** current effective egress rate cap, bits per second (for display) */
+    bitsPerSecond: number;
+};
+declare const quota$1: () => Promise<QuotaStatus>;
+
+declare const lookup: <T extends boolean = false>(hostname: string, options?: {
+    all?: T;
+    family: 0 | 4 | 6;
+}) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;
+
+type dns_AddressLookupResult = AddressLookupResult;
+declare const dns_lookup: typeof lookup;
+declare namespace dns {
+  export { dns_lookup as lookup };
+  export type { dns_AddressLookupResult as AddressLookupResult };
+}
+
+type ReadOptions = BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    flag?: string;
+} | null | undefined;
+type WriteOptions = BufferEncoding | {
+    encoding?: BufferEncoding | null;
+    mode?: number;
+    flag?: string;
+    contentType?: string;
+} | null | undefined;
+type WriteData = string | Uint8Array | ArrayBuffer | DataView;
+type MakeOptions = {
+    recursive?: boolean;
+} | number | null | undefined;
+type Callback<R> = (error: NodeJS.ErrnoException | null, result?: R) => void;
+type Stats = {
+    size: number;
+    mtimeMs: number;
+    mtime: Date;
+    atimeMs: number;
+    ctimeMs: number;
+    mode: number;
+    isFile: () => boolean;
+    isDirectory: () => boolean;
+    isSymbolicLink: () => boolean;
+};
+
+type FileEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string;
+};
+type StorageQuota = {
+    usedBytes: number;
+    limitBytes: number;
+    remaining: number;
+    objects: number;
+    maxObjects: number;
+};
+declare const quota: () => Promise<StorageQuota>;
+
+declare const available$1: () => Promise<boolean>;
+declare const readFile: (path: node_fs.PathLike, a: ReadOptions | Callback<Buffer | string>, b?: Callback<Buffer | string>) => void;
+declare const writeFile: (path: node_fs.PathLike, data: WriteData, a: WriteOptions | Callback<void>, b?: Callback<void>) => void;
+declare const unlink: (path: node_fs.PathLike, callback: Callback<void>) => void;
+declare const rename: (from: node_fs.PathLike, to: node_fs.PathLike, callback: Callback<void>) => void;
+declare const readdir: (path: node_fs.PathLike, a: unknown, b?: Callback<string[]>) => void;
+declare const mkdir: (path: node_fs.PathLike, a: MakeOptions | Callback<void>, b?: Callback<void>) => void;
+declare const rm: (path: node_fs.PathLike, a: {
+    recursive?: boolean;
+} | Callback<void>, b?: Callback<void>) => void;
+declare const stat: (path: node_fs.PathLike, callback: Callback<Stats>) => void;
+declare const promises: {
+    readFile: (path: node_fs.PathLike, options?: ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: node_fs.PathLike, data: WriteData, options?: WriteOptions) => Promise<void>;
+    unlink: (path: node_fs.PathLike) => Promise<void>;
+    rename: (from: node_fs.PathLike, to: node_fs.PathLike) => Promise<void>;
+    readdir: (path: node_fs.PathLike) => Promise<string[]>;
+    mkdir: (_path?: node_fs.PathLike, _options?: MakeOptions) => Promise<void>;
+    rm: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: node_fs.PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    stat: (path: node_fs.PathLike) => Promise<Stats>;
+    lstat: (path: node_fs.PathLike) => Promise<Stats>;
+    access: (path: node_fs.PathLike) => Promise<void>;
+};
+
+type fs_FileEntry = FileEntry;
+type fs_Stats = Stats;
+type fs_StorageQuota = StorageQuota;
+declare const fs_mkdir: typeof mkdir;
+declare const fs_promises: typeof promises;
+declare const fs_quota: typeof quota;
+declare const fs_readFile: typeof readFile;
+declare const fs_readdir: typeof readdir;
+declare const fs_rename: typeof rename;
+declare const fs_rm: typeof rm;
+declare const fs_stat: typeof stat;
+declare const fs_unlink: typeof unlink;
+declare const fs_writeFile: typeof writeFile;
+declare namespace fs {
+  export { available$1 as available, fs_mkdir as mkdir, fs_promises as promises, fs_quota as quota, fs_readFile as readFile, fs_readdir as readdir, fs_rename as rename, fs_rm as rm, fs_stat as stat, fs_unlink as unlink, fs_writeFile as writeFile };
+  export type { fs_FileEntry as FileEntry, fs_Stats as Stats, fs_StorageQuota as StorageQuota };
+}
+
+declare const isIPv4: (input: string) => boolean;
+declare const isIPv6: (input: string) => boolean;
+declare const isIP: (input: string) => 0 | 4 | 6;
+
+type WebVpnTcpSocket = Resolvers['cloud']['webvpn']['tcpSocket'];
+type WebVpnTcpSocketListener = Resolvers['cloud']['webvpn']['tcpSocketListener'];
+
+declare class Socket$1 extends Stream.Duplex implements Socket$2 {
+    _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$1 {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+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$1 & {
+        connection?: ReturnType<WebVpnTcpSocketListener>;
+    }, connectionListener?: (socket: Socket$1) => 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 connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
+declare const createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
+declare const createServer$1: (options?: ServerOpts | ((socket: Socket$1) => void), connectionListener?: (socket: Socket$1) => void) => Server$1;
+
+declare const _default$1: {
+    Socket: typeof Socket$1;
+    Server: typeof Server$1;
+    connect: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
+    createConnection: (options: SocketConnectOpts, connectionListener?: () => void) => Socket$1;
+    createServer: (options?: ServerOpts | ((socket: Socket$1) => void), connectionListener?: (socket: Socket$1) => void) => Server$1;
+    isIP: (input: string) => 0 | 4 | 6;
+    isIPv4: (input: string) => boolean;
+    isIPv6: (input: string) => boolean;
+};
+
+declare const net_connect: typeof connect;
+declare const net_createConnection: typeof createConnection;
+declare const net_isIP: typeof isIP;
+declare const net_isIPv4: typeof isIPv4;
+declare const net_isIPv6: typeof isIPv6;
+declare namespace net {
+  export {
+    Server$1 as Server,
+    Socket$1 as Socket,
+    _default$1 as _default,
+    net_connect as connect,
+    net_createConnection as createConnection,
+    createServer$1 as createServer,
+    _default$1 as default,
+    net_isIP as isIP,
+    net_isIPv4 as isIPv4,
+    net_isIPv6 as isIPv6,
+  };
+}
+
+type WebVpnUdpSocket = Resolvers['cloud']['webvpn']['udpSocket'];
+interface EventEmitterOptions {
+    /**
+     * Enables automatic capturing of promise rejection.
+     */
+    captureRejections?: boolean | undefined;
+}
+declare class Socket extends EventEmitter implements Socket$3 {
+    _type: 'udp4' | 'udp6';
+    _localAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _remoteAddress?: {
+        address: string;
+        family: string;
+        port: number;
+    };
+    _webVPNUdpSocketPromise?: Promise<Awaited<ReturnType<WebVpnUdpSocket>> | undefined>;
+    _dataPort?: MessagePort;
+    _socketId?: number;
+    _sendQueue: Uint8Array[];
+    _sendQueueBytes: number;
+    _sendFlushScheduled: boolean;
+    _peerTailCache: Map<string, Uint8Array<ArrayBufferLike>>;
+    constructor(options: SocketOptions & EventEmitterOptions & {
+        connection?: ReturnType<WebVpnUdpSocket>;
+    });
+    _lastRecvBufferSize: number;
+    _lastSendBufferSize: number;
+    _lastTtl: number;
+    _lastMulticastTtl: number;
+    _lastMulticastLoopback: boolean;
+    _setUdpOption(option: UdpSocketOption): void;
+    _onDataPortBatch(buffer: ArrayBuffer): void;
+    _peerTail(address: string | undefined, port: number | undefined): Uint8Array;
+    _portSend(message: Uint8Array, address: string | undefined, port: number | undefined): void;
+    addMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    address(): AddressInfo;
+    bind(port?: number | undefined, address?: string | undefined, callback?: (() => void) | undefined): this;
+    bind(port?: number | undefined, callback?: (() => void) | undefined): this;
+    bind(callback?: (() => void) | undefined): this;
+    bind(options: BindOptions, callback?: (() => void) | undefined): this;
+    close(callback?: (() => void) | undefined): this;
+    connect(port: number, address?: string, callback?: () => void): void;
+    connect(port: number, callback: () => void): void;
+    disconnect(): void;
+    dropMembership(multicastAddress: string, multicastInterface?: string | undefined): void;
+    getRecvBufferSize(): number;
+    getSendBufferSize(): number;
+    getSendQueueSize(): number;
+    getSendQueueCount(): number;
+    ref(): this;
+    remoteAddress(): AddressInfo;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | readonly any[] | Uint8Array, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, address?: string | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, port?: number | undefined, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: string | Uint8Array, offset: number, length: number, callback?: ((error: Error | null, bytes: number) => void) | undefined): void;
+    send(msg: unknown, offset?: unknown, length?: unknown, port?: unknown, address?: unknown, callback?: unknown): void;
+    setBroadcast(flag: boolean): void;
+    setMulticastInterface(multicastInterface: string): void;
+    setMulticastLoopback(flag: boolean): boolean;
+    setMulticastTTL(ttl: number): number;
+    setRecvBufferSize(size: number): void;
+    setSendBufferSize(size: number): void;
+    setTTL(ttl: number): number;
+    unref(): this;
+    addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string | undefined): void;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+declare const createSocket: (options: SocketType | SocketOptions, callback?: (msg: Buffer$1, rinfo: RemoteInfo) => void) => Socket;
+
+type dgram_Socket = Socket;
+declare const dgram_Socket: typeof Socket;
+declare const dgram_createSocket: typeof createSocket;
+declare namespace dgram {
+  export {
+    dgram_Socket as Socket,
+    dgram_createSocket as createSocket,
+  };
+}
+
+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[];
+}
+interface ParserHandlers {
+    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;
+}
+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$1;
+    constructor(socket: Socket$1);
+    get connection(): Socket$1;
+    _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$1 | 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$1, 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$1, _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;
+}
+declare class ServerResponse extends OutgoingMessage {
+    statusCode: number;
+    statusMessage?: string;
+    private _writeHeadCalled;
+    sendDate: boolean;
+    req: IncomingMessage;
+    socket: Socket$1 | 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;
+}
+declare class ClientRequest extends OutgoingMessage {
+    method: string;
+    path: string;
+    host: string;
+    protocol: string;
+    socket: Socket$1;
+    /** alias retained for Node compatibility */
+    get connection(): Socket$1;
+    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$1, 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;
+}
+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;
+}
+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;
+};
+
+type http_Agent = Agent;
+declare const http_Agent: typeof Agent;
+type http_ClientRequest = ClientRequest;
+declare const http_ClientRequest: typeof ClientRequest;
+type http_ClientRequestArgs = ClientRequestArgs;
+type http_HTTPParser = HTTPParser;
+declare const http_HTTPParser: typeof HTTPParser;
+type http_IncomingMessage = IncomingMessage;
+declare const http_IncomingMessage: typeof IncomingMessage;
+declare const http_METHODS: typeof METHODS;
+type http_ParsedHead = ParsedHead;
+type http_RequestListener = RequestListener;
+declare const http_STATUS_CODES: typeof STATUS_CODES;
+type http_Server = Server;
+type http_ServerResponse = ServerResponse;
+declare const http_ServerResponse: typeof ServerResponse;
+type http_ServerResponseOptions = ServerResponseOptions;
+declare const http__default: typeof _default;
+declare const http_createServer: typeof createServer;
+declare const http_get: typeof get;
+declare const http_globalAgent: typeof globalAgent;
+declare const http_request: typeof request;
+declare namespace http {
+  export { http_Agent as Agent, http_ClientRequest as ClientRequest, http_HTTPParser as HTTPParser, http_IncomingMessage as IncomingMessage, http_METHODS as METHODS, http_STATUS_CODES as STATUS_CODES, http_ServerResponse as ServerResponse, http__default as _default, http_createServer as createServer, _default as default, http_get as get, http_globalAgent as globalAgent, http_request as request };
+  export type { http_ClientRequestArgs as ClientRequestArgs, http_ParsedHead as ParsedHead, http_RequestListener as RequestListener, http_Server as Server, http_ServerResponseOptions as ServerResponseOptions };
+}
+
+declare const available: () => boolean;
+
+export { available, dgram, dns, cloudFetch as fetch, fs, http, net, quota$1 as quota };
+export type { QuotaStatus };