@fkn/lib 0.6.0 → 0.6.1

package/account.d.ts

@@ -0,0 +1,15 @@
+declare namespace account_d_exports {
+  export { AccountInfo, info, login, logout, onChange };
+}
+type AccountInfo = {
+  /** the account's display name (a username, not necessarily a real name) */name: string; /** profile image URL, or null if none is set */
+  image: string | null; /** the account has an active paid subscription */
+  premium: boolean; /** when the current subscription lapses, as a ms epoch, or null when not subscribed */
+  premiumUntil: number | null;
+};
+declare const login: () => Promise<boolean>;
+declare const logout: () => Promise<void>;
+declare const info: () => Promise<AccountInfo | null>;
+declare const onChange: (callback: () => void) => Promise<() => void>;
+//#endregion
+export { AccountInfo, info, login, logout, onChange, account_d_exports as t };

package/api-BYUraih6.d.ts

@@ -0,0 +1,524 @@
+import { C as PackagesFail, _ as ConnectOptions, b as PackageQuery, v as InstallOptions, w as PickOptions, x as PackageResult, y as InstalledPackage } from "./packages-D36R2vBv.js";
+import { t as AddressLookupResult } from "./lookup-BtwWaCZJ.js";
+import { Address4, Address6 } from "ip-address";
+
+//#region src/api/storage.d.ts
+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;
+//#endregion
+//#region src/api/webvpn/packets/tcp.d.ts
+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: import("ip-address").Address4 | import("ip-address").Address6;
+  readonly localPort: number;
+  readonly remoteAddressType: 0 | 1;
+  readonly remoteAddress: import("ip-address").Address4 | import("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>;
+//#endregion
+//#region src/api/local-net/index.d.ts
+type LocalTcpSocket = {
+  localAddress: string;
+  localFamily: 'IPv4' | 'IPv6';
+  localPort: number;
+  remoteAddress: string;
+  remoteFamily: 'IPv4' | 'IPv6';
+  remotePort: number;
+  dataReadableStream: ReadableStream<Uint8Array>;
+  dataWritableStream: WritableStream<Uint8Array>;
+  end: () => Promise<void>;
+  destroy: () => Promise<void>;
+  destroySoon: () => Promise<void>;
+  resetAndDestroy: () => Promise<void>;
+  setOption: (option: TcpSocketOption) => Promise<void>;
+};
+//#endregion
+//#region src/api/webvpn/packets/tcp-listener.d.ts
+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: import("ip-address").Address4 | import("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>;
+//#endregion
+//#region src/api/webvpn/packets/udp.d.ts
+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: import("ip-address").Address4 | import("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: import("ip-address").Address4 | import("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>;
+//#endregion
+//#region src/api/webvpn/packets/metadata.d.ts
+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;
+//#endregion
+//#region src/api/webvpn/webtransport.d.ts
+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>>;
+//#endregion
+//#region src/api/webvpn/tcp.d.ts
+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>>;
+//#endregion
+//#region src/api/quota.d.ts
+type Quota = {
+  overQuota: boolean;
+  remaining: number;
+  usedBytes: number;
+  limitBytes: number;
+  premium: boolean;
+  bytesPerSecond: number;
+};
+//#endregion
+//#region src/api/account.d.ts
+type Account = {
+  name: string;
+  image: string | null;
+  premium: boolean;
+  premiumUntil: string | null;
+};
+//#endregion
+//#region src/api/index.d.ts
+declare const resolvers: {
+  readonly cloud: {
+    readonly fetch: (input: string | Request | URL, 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<LocalTcpSocket>;
+      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 packages: {
+    search: (query: PackageQuery) => Promise<{
+      results: PackageResult[];
+    } | PackagesFail>;
+    pick: (query: PackageQuery, options?: PickOptions) => Promise<{
+      results: PackageResult[];
+      failed: string[];
+    } | {
+      declined: true;
+    } | PackagesFail>;
+    install: (uri: string, options?: InstallOptions) => Promise<{
+      installed: InstalledPackage;
+    } | {
+      declined: true;
+    } | PackagesFail>;
+    list: () => Promise<{
+      results: InstalledPackage[];
+    }>;
+    uninstall: (uri: string) => Promise<{
+      ok: true;
+    } | PackagesFail>;
+    connect: (uri: string, options?: ConnectOptions) => Promise<{
+      port: MessagePort;
+      closed: Promise<void>;
+    } | PackagesFail>;
+  };
+  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 | Request | URL, init?: (RequestInit | undefined) & {
+    render?: boolean;
+  }) => Promise<Response>;
+  readonly webVpnTcpSocket: ({
+    remoteAddress: _remoteAddress,
+    remotePort
+  }: {
+    remoteAddress: string;
+    remotePort: number;
+  }) => Promise<LocalTcpSocket>;
+  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;
+//#endregion
+export { TcpSocketOption as i, UdpSocketOption as n, LocalTcpSocket as r, Resolvers as t };

package/cloud/dgram.d.ts

@@ -0,0 +1,2 @@
+import _default, { Socket, createSocket } from "../dgram.js";
+export { Socket, createSocket, _default as default };

package/cloud/dns.d.ts

@@ -0,0 +1,3 @@
+import { t as AddressLookupResult } from "../lookup-BtwWaCZJ.js";
+import { lookup } from "../dns.js";
+export { type AddressLookupResult, lookup };

package/cloud/fs/promises.d.ts

@@ -0,0 +1,9 @@
+import { a as WriteData, i as Stats, n as MakeOptions, o as WriteOptions, r as ReadOptions } from "../../index-C6ZoDJg8.js";
+//#region src/lib/cloud/fs-promises.d.ts
+declare const readFile: (path: import("node:fs").PathLike, options?: ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: WriteData, options?: WriteOptions) => Promise<void>, unlink: (path: import("node:fs").PathLike) => Promise<void>, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>, readdir: (path: import("node:fs").PathLike) => Promise<string[]>, mkdir: (_path?: import("node:fs").PathLike, _options?: MakeOptions) => Promise<void>, rm: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => Promise<void>, rmdir: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+  }) => Promise<void>, stat: (path: import("node:fs").PathLike) => Promise<Stats>, lstat: (path: import("node:fs").PathLike) => Promise<Stats>, access: (path: import("node:fs").PathLike) => Promise<void>;
+//#endregion
+export { access, lstat, mkdir, readFile, readdir, rename, rm, rmdir, stat, unlink, writeFile };

package/cloud/fs.d.ts

@@ -0,0 +1,3 @@
+import { i as Stats } from "../index-C6ZoDJg8.js";
+import { a as readFile, c as rm, d as writeFile, f as FileEntry, i as promises, l as stat, m as quota, o as readdir, p as StorageQuota, r as mkdir, s as rename, t as available, u as unlink } from "../fs-K7ROdxDx.js";
+export { type FileEntry, type Stats, type StorageQuota, available, mkdir, promises, quota, readFile, readdir, rename, rm, stat, unlink, writeFile };

package/cloud/http.d.ts

@@ -0,0 +1,2 @@
+import { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, createServer, get, globalAgent, request } from "../http.js";
+export { Agent, ClientRequest, ClientRequestArgs, HTTPParser, IncomingMessage, METHODS, ParsedHead, RequestListener, STATUS_CODES, Server, ServerResponse, ServerResponseOptions, _default, _default as default, createServer, get, globalAgent, request };

package/cloud/net.d.ts

@@ -0,0 +1,2 @@
+import { a as createConnection, c as isIP, i as connect, l as isIPv4, n as Socket, o as createServer, r as _default, t as Server, u as isIPv6 } from "../net-BDW1AVX1.js";
+export { Server, Socket, _default, _default as default, connect, createConnection, createServer, isIP, isIPv4, isIPv6 };

package/cloud-gklfa4ZN.d.ts

@@ -0,0 +1,41 @@
+import { t as Resolvers } from "./api-BYUraih6.js";
+import { b as Frame, y as AttachFrameOptions } from "./index-BJztAQIP.js";
+import { t as dns_d_exports } from "./dns.js";
+import { n as fs_d_exports } from "./fs-K7ROdxDx.js";
+import { s as net_d_exports } from "./net-BDW1AVX1.js";
+import { t as dgram_d_exports } from "./dgram.js";
+import { t as http_d_exports } from "./http.js";
+
+//#region src/lib/proxy.d.ts
+type ProxyFetch = Resolvers['cloud']['fetch'];
+type FetchParameters = Parameters<ProxyFetch>;
+declare const cloudFetch: (input: FetchParameters[0], init?: FetchParameters[1]) => Promise<Response>;
+//#endregion
+//#region src/lib/cloud/frame.d.ts
+declare const attachFrame: ({
+  iframe,
+  domains,
+  syncCookies,
+  lockdown
+}: AttachFrameOptions) => Promise<Frame>;
+//#endregion
+//#region src/lib/quota.d.ts
+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: () => Promise<QuotaStatus>;
+declare namespace cloud_d_exports {
+  export { QuotaStatus, attachFrame, available, dgram_d_exports as dgram, dns_d_exports as dns, cloudFetch as fetch, fs_d_exports as fs, http_d_exports as http, net_d_exports as net, quota };
+}
+declare const available: () => boolean;
+//#endregion
+export { attachFrame as a, quota as i, cloud_d_exports as n, cloudFetch as o, QuotaStatus as r, available as t };

package/cloud.d.ts

@@ -0,0 +1,7 @@
+import { a as attachFrame, i as quota, o as cloudFetch, r as QuotaStatus, t as available } from "./cloud-gklfa4ZN.js";
+import { t as dns_d_exports } from "./dns.js";
+import { n as fs_d_exports } from "./fs-K7ROdxDx.js";
+import { s as net_d_exports } from "./net-BDW1AVX1.js";
+import { t as dgram_d_exports } from "./dgram.js";
+import { t as http_d_exports } from "./http.js";
+export { type QuotaStatus, attachFrame, available, dgram_d_exports as dgram, dns_d_exports as dns, cloudFetch as fetch, fs_d_exports as fs, http_d_exports as http, net_d_exports as net, quota };

package/connect-button-D8KXSL6s.d.ts

@@ -0,0 +1,4 @@
+//#region src/lib/connect-button.d.ts
+declare const connectButtonUrl: (origin?: string) => string;
+//#endregion
+export { connectButtonUrl as t };

package/desktop.d.ts

@@ -0,0 +1,52 @@
+declare namespace desktop_d_exports {
+  export { available, dgram, dns, fetch, fs, net };
+}
+declare const available: () => boolean;
+declare const fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+declare const dns: {
+  lookup: (..._args: unknown[]) => never;
+};
+declare const net: {
+  connect: (..._args: unknown[]) => never;
+  createConnection: (..._args: unknown[]) => never;
+  createServer: (..._args: unknown[]) => never;
+};
+declare const dgram: {
+  createSocket: (..._args: unknown[]) => never;
+};
+declare const fs: {
+  available: () => Promise<boolean>;
+  readFile: (..._args: unknown[]) => never;
+  readFileSync: (..._args: unknown[]) => never;
+  writeFile: (..._args: unknown[]) => never;
+  writeFileSync: (..._args: unknown[]) => never;
+  appendFile: (..._args: unknown[]) => never;
+  appendFileSync: (..._args: unknown[]) => never;
+  existsSync: (..._args: unknown[]) => never;
+  stat: (..._args: unknown[]) => never;
+  statSync: (..._args: unknown[]) => never;
+  readdir: (..._args: unknown[]) => never;
+  readdirSync: (..._args: unknown[]) => never;
+  mkdir: (..._args: unknown[]) => never;
+  mkdirSync: (..._args: unknown[]) => never;
+  rm: (..._args: unknown[]) => never;
+  rmSync: (..._args: unknown[]) => never;
+  unlink: (..._args: unknown[]) => never;
+  unlinkSync: (..._args: unknown[]) => never;
+  rename: (..._args: unknown[]) => never;
+  renameSync: (..._args: unknown[]) => never;
+  mount: (..._args: unknown[]) => never;
+  flush: (..._args: unknown[]) => never;
+  promises: {
+    readFile: (..._args: unknown[]) => never;
+    writeFile: (..._args: unknown[]) => never;
+    unlink: (..._args: unknown[]) => never;
+    rename: (..._args: unknown[]) => never;
+    readdir: (..._args: unknown[]) => never;
+    mkdir: (..._args: unknown[]) => never;
+    rm: (..._args: unknown[]) => never;
+    stat: (..._args: unknown[]) => never;
+  };
+};
+//#endregion
+export { available, dgram, dns, fetch, fs, net, desktop_d_exports as t };