@fkn/lib 0.6.0 → 0.6.1

package/api/data-plane.d.ts

@@ -1,28 +0,0 @@
-import { proxyFetch } from './proxy';
-import { webVpnTcpSocket, webVpnTcpSocketListener, webVpnUdpSocket } from './webvpn';
-import { dnsLookup } from './dns';
-import { fetchQuota } from './quota';
-import { storageAvailable, storageList, storageQuota, storageReadFile, storageWriteFile, storageDelete } from './storage';
-export declare const dataPlane: {
-    cloud: {
-        fetch: typeof proxyFetch;
-        quota: typeof fetchQuota;
-        dns: {
-            lookup: typeof dnsLookup;
-        };
-        fs: {
-            available: typeof storageAvailable;
-            list: typeof storageList;
-            quota: typeof storageQuota;
-            readFile: typeof storageReadFile;
-            writeFile: typeof storageWriteFile;
-            remove: typeof storageDelete;
-        };
-        webvpn: {
-            tcpSocket: typeof webVpnTcpSocket;
-            tcpSocketListener: typeof webVpnTcpSocketListener;
-            udpSocket: typeof webVpnUdpSocket;
-        };
-    };
-};
-export type DataPlane = typeof dataPlane;

package/api/dns/index.d.ts

@@ -1 +0,0 @@
-export * from './lookup';

package/api/dns/lookup.d.ts

@@ -1,8 +0,0 @@
-export type AddressLookupResult = {
-    address: string;
-    family: 0 | 4 | 6;
-};
-export declare const dnsLookup: <T extends boolean = false>(hostname: string, options?: {
-    all?: T;
-    family?: 0 | 4 | 6;
-}) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;

package/api/index.d.ts

@@ -1,78 +0,0 @@
-import { setOverlayHost } from './overlay';
-import { showInstallPrompt, hideInstallPrompt } from './install-prompt';
-import { promptConnect, disconnect, onConnectChange } from './connect';
-import { fetchAccount } from './account';
-export { registerSurface, setModal } from './overlay';
-declare const resolvers: {
-    readonly cloud: {
-        readonly fetch: typeof import("./proxy").proxyFetch;
-        readonly quota: typeof import("./quota").fetchQuota;
-        readonly dns: {
-            readonly lookup: typeof import("./dns").dnsLookup;
-        };
-        readonly fs: {
-            readonly available: typeof import("./storage").storageAvailable;
-            readonly list: typeof import("./storage").storageList;
-            readonly quota: typeof import("./storage").storageQuota;
-            readonly readFile: typeof import("./storage").storageReadFile;
-            readonly writeFile: typeof import("./storage").storageWriteFile;
-            readonly remove: typeof import("./storage").storageDelete;
-        };
-        readonly webvpn: {
-            readonly tcpSocket: typeof import("./webvpn").webVpnTcpSocket;
-            readonly tcpSocketListener: typeof import("./webvpn").webVpnTcpSocketListener;
-            readonly udpSocket: typeof import("./webvpn").webVpnUdpSocket;
-        };
-    };
-    readonly overlay: {
-        readonly setHost: typeof setOverlayHost;
-    };
-    readonly installPrompt: {
-        readonly show: typeof showInstallPrompt;
-        readonly hide: typeof hideInstallPrompt;
-    };
-    readonly connect: {
-        readonly prompt: typeof promptConnect;
-    };
-    readonly packages: {
-        search: (query: import("./packages").PackageQuery) => Promise<{
-            results: import("./packages").PackageResult[];
-        } | import("./packages").PackagesFail>;
-        pick: (query: import("./packages").PackageQuery, options?: import("./packages").PickOptions) => Promise<{
-            results: import("./packages").PackageResult[];
-            failed: string[];
-        } | {
-            declined: true;
-        } | import("./packages").PackagesFail>;
-        install: (uri: string, options?: import("./packages").InstallOptions) => Promise<{
-            installed: import("./packages").InstalledPackage;
-        } | {
-            declined: true;
-        } | import("./packages").PackagesFail>;
-        list: () => Promise<{
-            results: import("./packages").InstalledPackage[];
-        }>;
-        uninstall: (uri: string) => Promise<{
-            ok: true;
-        } | import("./packages").PackagesFail>;
-        connect: (uri: string, options?: import("./packages").ConnectOptions) => Promise<{
-            port: MessagePort;
-            closed: Promise<void>;
-        } | import("./packages").PackagesFail>;
-    };
-    readonly account: {
-        readonly info: typeof fetchAccount;
-        readonly login: typeof promptConnect;
-        readonly logout: typeof disconnect;
-        readonly onChange: typeof onConnectChange;
-    };
-    readonly proxyFetch: typeof import("./proxy").proxyFetch;
-    readonly webVpnTcpSocket: typeof import("./webvpn").webVpnTcpSocket;
-    readonly webVpnTcpSocketListener: typeof import("./webvpn").webVpnTcpSocketListener;
-    readonly webVpnUdpSocket: typeof import("./webvpn").webVpnUdpSocket;
-    readonly dnsLookup: typeof import("./dns").dnsLookup;
-    readonly setOverlayHost: typeof setOverlayHost;
-    readonly showInstallPrompt: typeof showInstallPrompt;
-    readonly hideInstallPrompt: typeof hideInstallPrompt;
-};
-export type Resolvers = typeof resolvers;

package/api/install-prompt.d.ts

@@ -1,2 +0,0 @@
-export declare const showInstallPrompt: (reason?: string) => Promise<void>;
-export declare const hideInstallPrompt: () => void;

package/api/local-net/index.d.ts

@@ -1,43 +0,0 @@
-import type { TcpSocketOption } from '../webvpn/packets/tcp';
-import { Address4, Address6 } from 'ip-address';
-export declare const isLoopbackAddress: (addressType: 0 | 1, address: Address4 | Address6) => boolean;
-export type LocalBindFamily = 'IPv4' | 'IPv6' | 'dual';
-export declare const localBindFamily: (addressType: 0 | 1, address: Address4 | Address6) => LocalBindFamily;
-export 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>;
-};
-export type LocalUdpDatagram = {
-    fromPort: number;
-    ipv6: boolean;
-    data: ArrayBuffer;
-};
-type LocalTcpListener = {
-    port: number;
-    family: LocalBindFamily;
-    onConnection: (socket: LocalTcpSocket) => void;
-};
-type LocalUdpSocket = {
-    port: number;
-    family: LocalBindFamily;
-    deliver: (datagram: LocalUdpDatagram) => void;
-};
-export declare const registerLocalTcpListener: (listener: LocalTcpListener) => (() => void);
-export declare const registerLocalUdpSocket: (socket: LocalUdpSocket) => (() => void);
-export declare const lookupLocalUdpSocket: (port: number, ipv6: boolean) => LocalUdpSocket | undefined;
-export declare const connectLocalTcp: ({ remotePort, ipv6 }: {
-    remotePort: number;
-    ipv6: boolean;
-}) => LocalTcpSocket | undefined;
-export {};

package/api/overlay-mount.d.ts

@@ -1,2 +0,0 @@
-import type { VNode } from 'preact';
-export declare const mountOverlay: (vnode: VNode) => () => void;

package/api/overlay.d.ts

@@ -1,17 +0,0 @@
-type SurfaceRect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-};
-type OverlayState = {
-    modal: boolean;
-    rects: SurfaceRect[];
-};
-type OverlayPush = (state: OverlayState) => unknown;
-export declare const setOverlayHost: (push: OverlayPush) => void;
-export declare const registerSurface: (element: HTMLElement, { inflate }?: {
-    inflate?: number | undefined;
-}) => () => boolean;
-export declare const setModal: (value: boolean) => void;
-export {};

package/api/packages/host.d.ts

@@ -1,12 +0,0 @@
-import type { PackagesFail } from './types';
-export declare const teardownPackageFrame: (uri: string) => void;
-export type PluginIdentity = {
-    uri: string;
-    name: string;
-    version: string;
-};
-export declare const pluginForFrameWindow: (win: unknown) => PluginIdentity | null;
-export declare const connectPackage: (uri: string, protocol: string | null) => Promise<{
-    port: MessagePort;
-    closed: Promise<void>;
-} | PackagesFail>;

package/api/packages/identity.d.ts

@@ -1 +0,0 @@
-export declare const getCallerId: () => string | null;

package/api/packages/index.d.ts

@@ -1,34 +0,0 @@
-import type { ConnectOptions, InstallOptions, InstalledPackage, PackageQuery, PackageResult, PackagesFail, PickOptions } from './types';
-export type { PackageQuery, PackageResult, InstalledPackage, PickOptions, InstallOptions, ConnectOptions, PackagesFail, PackagesErrorCode } from './types';
-declare const search: (query: PackageQuery) => Promise<{
-    results: PackageResult[];
-} | PackagesFail>;
-declare const pick: (query: PackageQuery, options?: PickOptions) => Promise<{
-    results: PackageResult[];
-    failed: string[];
-} | {
-    declined: true;
-} | PackagesFail>;
-declare const install: (uri: string, options?: InstallOptions) => Promise<{
-    installed: InstalledPackage;
-} | {
-    declined: true;
-} | PackagesFail>;
-declare const list: () => Promise<{
-    results: InstalledPackage[];
-}>;
-declare const uninstall: (uri: string) => Promise<{
-    ok: true;
-} | PackagesFail>;
-declare const connect: (uri: string, options?: ConnectOptions) => Promise<{
-    port: MessagePort;
-    closed: Promise<void>;
-} | PackagesFail>;
-export declare const packages: {
-    search: typeof search;
-    pick: typeof pick;
-    install: typeof install;
-    list: typeof list;
-    uninstall: typeof uninstall;
-    connect: typeof connect;
-};

package/api/packages/picker.d.ts

@@ -1,28 +0,0 @@
-/** @jsxImportSource preact */
-import type { PackageResult } from './types';
-import { type PackagesFail } from './types';
-type FinalizeResult = {
-    results: PackageResult[];
-    failed: string[];
-};
-type PickerProps = {
-    title?: string;
-    results: PackageResult[];
-    multiple: boolean;
-    finalize: (selected: PackageResult[]) => Promise<FinalizeResult>;
-    onResolve: (result: FinalizeResult | null) => void;
-};
-type ConfirmProps = {
-    name: string;
-    version: string;
-    description: string;
-    publisher: string | null;
-    onResolve: (accepted: boolean) => void;
-};
-export declare const pickPackages: (props: Omit<PickerProps, 'onResolve'>) => Promise<FinalizeResult | {
-    declined: true;
-} | PackagesFail>;
-export declare const confirmInstall: (props: Omit<ConfirmProps, 'onResolve'>) => Promise<{
-    accepted: boolean;
-} | PackagesFail>;
-export {};

package/api/packages/registry.d.ts

@@ -1,20 +0,0 @@
-import type { PackageQuery, PackageResult, PackagesFail } from './types';
-export declare const isValidVersion: (version: string) => boolean;
-export type ParsedNpmUri = {
-    uri: string;
-    name: string;
-    version: string | null;
-};
-export declare const parseNpmUri: (input: unknown) => ParsedNpmUri | undefined;
-export declare const searchPackages: (query: PackageQuery, isInstalled: (uri: string) => boolean) => Promise<{
-    results: PackageResult[];
-} | PackagesFail>;
-export type ResolvedPackage = {
-    name: string;
-    version: string;
-    description: string;
-    publisher: string | null;
-};
-export declare const resolvePackument: (name: string, version?: string | null) => Promise<{
-    resolved: ResolvedPackage;
-} | PackagesFail>;

package/api/packages/store.d.ts

@@ -1,6 +0,0 @@
-import type { InstalledPackage } from './types';
-export declare const listRecords: (installer: string) => InstalledPackage[];
-export declare const getRecord: (installer: string, uri: string) => InstalledPackage | undefined;
-export declare const putRecord: (installer: string, record: InstalledPackage) => boolean;
-export declare const deleteRecord: (installer: string, uri: string) => void;
-export declare const onRecordsChange: (listener: () => void) => (() => void);

package/api/packages/types.d.ts

@@ -1,56 +0,0 @@
-export type PackageQuery = {
-    /** package kind, e.g. 'plugin' - becomes the keyword `fkn-type:<type>` */
-    type: string;
-    /** host app scope, e.g. 'stub' - becomes the keyword `fkn-<type>--<id>` */
-    id?: string;
-    /** package source; npm is the only origin implemented */
-    origin?: 'npm';
-    /** free text mixed into the registry query */
-    text?: string;
-    /** result count, clamped to 1..100 */
-    size?: number;
-};
-export type PackageResult = {
-    /** canonical version-free uri, e.g. 'npm:@banou/stub-plugin-foo' */
-    uri: string;
-    origin: 'npm';
-    name: string;
-    /** latest version per the search index - display only, install re-resolves from the packument */
-    version: string;
-    description: string;
-    keywords: string[];
-    publisher: string | null;
-    downloadsMonthly: number | null;
-    links: {
-        npm?: string;
-        homepage?: string;
-        repository?: string;
-    };
-    /** installed by the calling app */
-    installed: boolean;
-};
-export type InstalledPackage = {
-    uri: string;
-    name: string;
-    version: string;
-    installedAt: number;
-};
-export type PickOptions = {
-    /** untrusted, rendered as text in the picker header */
-    title?: string;
-    multiple?: boolean;
-};
-export type InstallOptions = {
-    /** exact version to pin; defaults to the packument's latest dist-tag */
-    version?: string;
-};
-export type ConnectOptions = {
-    /** opaque contract tag delivered to the package's onConnect, e.g. 'stub-source@1' */
-    protocol?: string;
-};
-export type PackagesErrorCode = 'invalid' | 'not-installed' | 'unaddressable' | 'timeout' | 'unavailable' | 'denied';
-export type PackagesFail = {
-    error: PackagesErrorCode;
-    message: string;
-};
-export declare const packagesFail: (error: PackagesErrorCode, message: string) => PackagesFail;

package/api/preconnect.d.ts

@@ -1 +0,0 @@
-export declare const warmEgressOrigins: () => void;

package/api/proxy/index.d.ts

@@ -1 +0,0 @@
-export { proxyFetch } from './proxy-fetch';

package/api/proxy/proxy-fetch.d.ts

@@ -1,5 +0,0 @@
-type FetchArgs = Parameters<typeof fetch>;
-export declare const proxyFetch: (input: FetchArgs[0], init?: FetchArgs[1] & {
-    render?: boolean;
-}) => Promise<Response>;
-export {};

package/api/quota.d.ts

@@ -1,10 +0,0 @@
-export type Quota = {
-    overQuota: boolean;
-    remaining: number;
-    usedBytes: number;
-    limitBytes: number;
-    premium: boolean;
-    bytesPerSecond: number;
-};
-export declare const fetchQuota: () => Promise<Quota>;
-export declare const notifyEgress: () => void;

package/api/rate-token.d.ts

@@ -1,3 +0,0 @@
-export declare const peekRateToken: () => string | null;
-export declare const primeRateToken: () => void;
-export declare const getRateToken: () => Promise<string | null>;

package/api/session-limit.d.ts

@@ -1 +0,0 @@
-export declare const showSessionLimitNotice: (reason: string) => void;

package/api/storage.d.ts

@@ -1,20 +0,0 @@
-export type StorageEntry = {
-    path: string;
-    size: number;
-    contentType: string | null;
-    updatedAt: string;
-};
-export type StorageQuota = {
-    usedBytes: number;
-    limitBytes: number;
-    remaining: number;
-    objects: number;
-    maxObjects: number;
-};
-export type WriteData = ArrayBuffer | Uint8Array | string;
-export declare const storageAvailable: () => Promise<boolean>;
-export declare const storageList: () => Promise<StorageEntry[]>;
-export declare const storageQuota: () => Promise<StorageQuota>;
-export declare const storageDelete: (path: string) => Promise<void>;
-export declare const storageReadFile: (path: string) => Promise<Uint8Array>;
-export declare const storageWriteFile: (path: string, data: WriteData, contentType: string | null) => Promise<void>;

package/api/toast.d.ts

@@ -1 +0,0 @@
-export declare const showQuotaToast: () => void;

package/api/token-source.d.ts

@@ -1,4 +0,0 @@
-export declare const setConnectTokenGetter: (getter: () => Promise<string | null>) => void;
-export declare const getConnectToken: () => Promise<string | null>;
-export declare const onConnectChange: (listener: () => void) => (() => void);
-export declare const emitConnectChange: () => void;

package/api/ui-events.d.ts

@@ -1,8 +0,0 @@
-export type UiEvent = {
-    type: 'quota-toast';
-} | {
-    type: 'session-limit';
-    reason: string;
-};
-export declare const setUiEventHandler: (nextHandler: (event: UiEvent) => void) => void;
-export declare const emitUiEvent: (event: UiEvent) => void;

package/api/ui-host.d.ts

@@ -1,2 +0,0 @@
-import type { UiEvent } from './ui-events';
-export declare const displayUiEvent: (event: UiEvent) => void;

package/api/webvpn/index.d.ts

@@ -1,3 +0,0 @@
-export { webVpnTcpSocket } from './tcp';
-export { webVpnTcpSocketListener } from './tcp-listener';
-export { webVpnUdpSocket } from './udp';

package/api/webvpn/packets/metadata.d.ts

@@ -1,31 +0,0 @@
-import type { ServerMetadataTcpSetOptionAckPacket, ServerMetadataTcpSocketConnectedPacket, ServerMetadataTcpSocketShutdownPacket } from './tcp';
-import type { ServerMetadataTcpSocketListenerBoundPacket, ServerMetadataTcpSocketListenerUnboundPacket } from './tcp-listener';
-import type { ServerMetadataUdpSetOptionAckPacket, ServerMetadataUdpSocketBoundPacket, ServerMetadataUdpSocketConnectedPacket, ServerMetadataUdpSocketUnboundPacket } from './udp';
-export declare const parseClientMetadataHeaderPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ClientMetadataHeaderPacket';
-    readonly offset: number;
-    readonly agentLength: number;
-    readonly agent: string;
-    readonly versionLength: number;
-    readonly version: string;
-};
-export type ClientMetadataHeaderPacket = Omit<ReturnType<typeof parseClientMetadataHeaderPacket>, 'offset'>;
-export declare const packClientMetadataPremiumTokenPacket: (token: string) => Uint8Array<ArrayBuffer>;
-export declare const packClientMetadataHeaderPacket: (packet: Pick<ClientMetadataHeaderPacket, 'agent' | 'version'>) => Uint8Array<ArrayBuffer>;
-export 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;
-};
-export type ServerMetadataHeaderPacket = ReturnType<typeof parseServerMetadataHeaderPacket>;
-export declare const packServerMetadataHeaderPacket: (packet: Pick<ServerMetadataHeaderPacket, 'agent' | 'version'>) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => ServerMetadataPacket;
-export type ServerMetadataPacket = ServerMetadataHeaderPacket | ServerMetadataTcpSocketConnectedPacket | ServerMetadataTcpSocketShutdownPacket | ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket | ServerMetadataUdpSocketBoundPacket | ServerMetadataUdpSocketUnboundPacket | ServerMetadataUdpSocketConnectedPacket | ServerMetadataTcpSetOptionAckPacket | ServerMetadataUdpSetOptionAckPacket;
-export declare const parseServerMetadataPackets: (buffer: ArrayBuffer) => {
-    packets: ServerMetadataPacket[];
-    remaining: ArrayBuffer;
-};
-export declare const createServerMetadataPacketTransformStream: () => TransformStream<Uint8Array<ArrayBufferLike>, ServerMetadataPacket>;

package/api/webvpn/packets/tcp-listener.d.ts

@@ -1,39 +0,0 @@
-export declare const parseClientMetadataTcpSocketListenerBindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly offset: number;
-    readonly id: number;
-    readonly localAddressType: 0 | 1;
-    readonly localAddress: import("ip-address").Address4 | import("ip-address").Address6;
-    readonly localPort: number;
-};
-export type ClientMetadataTcpSocketListenerBindPacket = ReturnType<typeof parseClientMetadataTcpSocketListenerBindPacket>;
-export declare const packClientMetadataTcpSocketListenerBindPacket: (packet: Omit<ClientMetadataTcpSocketListenerBindPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataTcpSocketListenerUnbindPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ClientMetadataTcpSocketListenerUnbindPacket';
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ClientMetadataTcpSocketListenerUnbindPacket = ReturnType<typeof parseClientMetadataTcpSocketListenerUnbindPacket>;
-export declare const packClientMetadataTcpSocketListenerUnbindPacket: (packet: Omit<ClientMetadataTcpSocketListenerUnbindPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export 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;
-};
-export type ServerMetadataTcpSocketListenerBoundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerBoundPacket>;
-export declare const packServerMetadataTcpSocketListenerBoundPacket: (packet: Omit<ServerMetadataTcpSocketListenerBoundPacket, '_type' | 'offset' | 'errorLength'>) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketListenerUnboundPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ServerMetadataTcpSocketListenerUnboundPacket';
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ServerMetadataTcpSocketListenerUnboundPacket = ReturnType<typeof parseServerMetadataTcpSocketListenerUnboundPacket>;
-export declare const packServerMetadataTcpSocketListenerUnboundPacket: (packet: Omit<ServerMetadataTcpSocketListenerUnboundPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export type ServerMetadataTcpSocketListenerPacket = ServerMetadataTcpSocketListenerBoundPacket | ServerMetadataTcpSocketListenerUnboundPacket;

package/api/webvpn/packets/tcp.d.ts

@@ -1,88 +0,0 @@
-export declare const parseClientMetadataTcpSocketConnectPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ClientMetadataTcpSocketConnectPacket';
-    readonly offset: number;
-    readonly id: number;
-    readonly remoteAddressType: 0 | 1;
-    readonly remoteAddress: import("ip-address").Address4 | import("ip-address").Address6;
-    readonly remotePort: number;
-};
-export type ClientMetadataTcpSocketConnectPacket = ReturnType<typeof parseClientMetadataTcpSocketConnectPacket>;
-export declare const packClientMetadataTcpSocketConnectPacket: (packet: Omit<ClientMetadataTcpSocketConnectPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export declare const parseClientMetadataTcpSocketTcpShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ClientMetadataTcpSocketTcpShutdownPacket';
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ClientMetadataTcpSocketTcpShutdownPacket = ReturnType<typeof parseClientMetadataTcpSocketTcpShutdownPacket>;
-export declare const packClientMetadataTcpSocketTcpShutdownPacket: (packet: Omit<ClientMetadataTcpSocketTcpShutdownPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export 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;
-};
-export type ServerMetadataTcpSocketConnectedPacket = ReturnType<typeof parseServerMetadataTcpSocketConnectedPacket>;
-export declare const packServerMetadataTcpSocketConnectedPacket: (packet: Omit<ServerMetadataTcpSocketConnectedPacket, '_type' | 'offset' | 'errorLength'>) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSocketShutdownPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    readonly _type: 'ServerMetadataTcpSocketShutdownPacket';
-    readonly offset: number;
-    readonly id: number;
-    readonly socketId: number;
-};
-export type ServerMetadataTcpSocketShutdownPacket = ReturnType<typeof parseServerMetadataTcpSocketShutdownPacket>;
-export declare const packServerMetadataTcpSocketShutdownPacket: (packet: Omit<ServerMetadataTcpSocketShutdownPacket, '_type' | 'offset'>) => Uint8Array<ArrayBuffer>;
-export type ClientMetadataTcpSocketPacket = ClientMetadataTcpSocketConnectPacket | ClientMetadataTcpSocketTcpShutdownPacket;
-export declare const TCP_OPTION_NODELAY: 0;
-export declare const TCP_OPTION_TTL: 1;
-export declare const TCP_OPTION_KEEPALIVE: 2;
-export declare const TCP_OPTION_SEND_BUFFER_SIZE: 3;
-export declare const TCP_OPTION_RECV_BUFFER_SIZE: 4;
-export 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;
-};
-export declare const parseClientMetadataTcpSetOptionPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: 'ClientMetadataTcpSetOptionPacket';
-    offset: number;
-    id: number;
-    socketId: number;
-    option: TcpSocketOption;
-};
-export type ClientMetadataTcpSetOptionPacket = ReturnType<typeof parseClientMetadataTcpSetOptionPacket>;
-export declare const packClientMetadataTcpSetOptionPacket: (packet: {
-    id: number;
-    socketId: number;
-    option: TcpSocketOption;
-}) => Uint8Array<ArrayBuffer>;
-export declare const parseServerMetadataTcpSetOptionAckPacket: (offset: number, buffer: ArrayBuffer, view: DataView) => {
-    _type: 'ServerMetadataTcpSetOptionAckPacket';
-    offset: number;
-    id: number;
-    socketId: number;
-    errorLength: number;
-    error: string;
-};
-export type ServerMetadataTcpSetOptionAckPacket = ReturnType<typeof parseServerMetadataTcpSetOptionAckPacket>;
-export declare const packServerMetadataTcpSetOptionAckPacket: (packet: Omit<ServerMetadataTcpSetOptionAckPacket, '_type' | 'offset' | 'errorLength'>) => Uint8Array<ArrayBuffer>;