@fkn/lib 0.5.4 → 0.6.0

package/lib/api.d.ts

@@ -0,0 +1,300 @@
+export type { Resolvers } from '../api';
+export declare const hasTransport: boolean;
+export declare const apiPromise: Promise<{
+    readonly cloud: {
+        readonly fetch: (input: string | Request | URL, init?: (RequestInit & {
+            render?: boolean;
+        }) | undefined) => Promise<Response>;
+        readonly quota: () => Promise<{
+            overQuota: boolean;
+            remaining: number;
+            usedBytes: number;
+            limitBytes: number;
+            premium: boolean;
+            bytesPerSecond: number;
+        }>;
+        readonly dns: {
+            readonly lookup: (hostname: string, options?: {
+                all?: boolean | undefined;
+                family?: 0 | 4 | 6;
+            } | undefined) => Promise<{
+                address: string;
+                family: 0 | 4 | 6;
+            }[] | {
+                address: string;
+                family: 0 | 4 | 6;
+            } | undefined>;
+        };
+        readonly fs: {
+            readonly available: () => Promise<boolean>;
+            readonly list: () => Promise<{
+                path: string;
+                size: number;
+                contentType: string | null;
+                updatedAt: string;
+            }[]>;
+            readonly quota: () => Promise<{
+                usedBytes: number;
+                limitBytes: number;
+                remaining: number;
+                objects: number;
+                maxObjects: number;
+            }>;
+            readonly readFile: (path: string) => Promise<Uint8Array<ArrayBufferLike>>;
+            readonly writeFile: (path: string, data: import("../api/storage").WriteData, contentType: string | null) => Promise<void>;
+            readonly remove: (path: string) => Promise<void>;
+        };
+        readonly webvpn: {
+            readonly tcpSocket: (args_0: {
+                remoteAddress: string;
+                remotePort: number;
+            }) => Promise<{
+                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: import("../api/webvpn/tcp").TcpSocketOption) => Promise<void>;
+            }>;
+            readonly tcpSocketListener: (args_0: {
+                localAddress: string;
+                localPort: number;
+                onConnection: (connection: import("../api/webvpn/tcp").TcpSocketResult) => void;
+            }) => Promise<{
+                localAddress: string;
+                localFamily: "IPv4" | "IPv6";
+                localPort: number;
+                close: () => Promise<void>;
+            }>;
+            readonly udpSocket: (args_0: {
+                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: (args_0: {
+                    remoteAddress: string;
+                    remotePort: number;
+                }) => Promise<void>;
+                send: (args_0: {
+                    message: ArrayBuffer;
+                    address?: string;
+                    port?: number;
+                }) => Promise<void>;
+                close: () => Promise<void>;
+                setOption: (option: import("../api/webvpn/udp").UdpSocketOption) => Promise<void>;
+            }>;
+        };
+    };
+    readonly overlay: {
+        readonly setHost: (push: (state: {
+            modal: boolean;
+            rects: {
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+            }[];
+        }) => unknown) => Promise<void>;
+    };
+    readonly installPrompt: {
+        readonly show: (reason?: string | undefined) => Promise<void>;
+        readonly hide: () => Promise<void>;
+    };
+    readonly connect: {
+        readonly prompt: (consumerOrigin: string) => Promise<boolean>;
+    };
+    readonly packages: {
+        search: (query: import("./packages").PackageQuery) => Promise<{
+            error: import("./packages").PackagesErrorCode;
+            message: string;
+        } | {
+            results: {
+                uri: string;
+                origin: 'npm';
+                name: string;
+                version: string;
+                description: string;
+                keywords: string[];
+                publisher: string | null;
+                downloadsMonthly: number | null;
+                links: {
+                    npm?: string;
+                    homepage?: string;
+                    repository?: string;
+                };
+                installed: boolean;
+            }[];
+        }>;
+        pick: (query: import("./packages").PackageQuery, options?: import("./packages").PickOptions | undefined) => Promise<{
+            error: import("./packages").PackagesErrorCode;
+            message: string;
+        } | {
+            results: {
+                uri: string;
+                origin: 'npm';
+                name: string;
+                version: string;
+                description: string;
+                keywords: string[];
+                publisher: string | null;
+                downloadsMonthly: number | null;
+                links: {
+                    npm?: string;
+                    homepage?: string;
+                    repository?: string;
+                };
+                installed: boolean;
+            }[];
+            failed: string[];
+        } | {
+            declined: true;
+        }>;
+        install: (uri: string, options?: import("./packages").InstallOptions | undefined) => Promise<{
+            error: import("./packages").PackagesErrorCode;
+            message: string;
+        } | {
+            installed: {
+                uri: string;
+                name: string;
+                version: string;
+                installedAt: number;
+            };
+        } | {
+            declined: true;
+        }>;
+        list: () => Promise<{
+            results: {
+                uri: string;
+                name: string;
+                version: string;
+                installedAt: number;
+            }[];
+        }>;
+        uninstall: (uri: string) => Promise<{
+            error: import("./packages").PackagesErrorCode;
+            message: string;
+        } | {
+            ok: true;
+        }>;
+        connect: (uri: string, options?: import("./packages").ConnectOptions | undefined) => Promise<{
+            error: import("./packages").PackagesErrorCode;
+            message: string;
+        } | {
+            port: MessagePort;
+            closed: Promise<void>;
+        }>;
+    };
+    readonly account: {
+        readonly info: () => Promise<{
+            name: string;
+            image: string | null;
+            premium: boolean;
+            premiumUntil: string | null;
+        } | null>;
+        readonly login: (consumerOrigin: string) => Promise<boolean>;
+        readonly logout: () => Promise<void>;
+        readonly onChange: (listener: () => void) => Promise<() => Promise<void>>;
+    };
+    readonly proxyFetch: (input: string | Request | URL, init?: (RequestInit & {
+        render?: boolean;
+    }) | undefined) => Promise<Response>;
+    readonly webVpnTcpSocket: (args_0: {
+        remoteAddress: string;
+        remotePort: number;
+    }) => Promise<{
+        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: import("../api/webvpn/tcp").TcpSocketOption) => Promise<void>;
+    }>;
+    readonly webVpnTcpSocketListener: (args_0: {
+        localAddress: string;
+        localPort: number;
+        onConnection: (connection: import("../api/webvpn/tcp").TcpSocketResult) => void;
+    }) => Promise<{
+        localAddress: string;
+        localFamily: "IPv4" | "IPv6";
+        localPort: number;
+        close: () => Promise<void>;
+    }>;
+    readonly webVpnUdpSocket: (args_0: {
+        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: (args_0: {
+            remoteAddress: string;
+            remotePort: number;
+        }) => Promise<void>;
+        send: (args_0: {
+            message: ArrayBuffer;
+            address?: string;
+            port?: number;
+        }) => Promise<void>;
+        close: () => Promise<void>;
+        setOption: (option: import("../api/webvpn/udp").UdpSocketOption) => Promise<void>;
+    }>;
+    readonly dnsLookup: (hostname: string, options?: {
+        all?: boolean | undefined;
+        family?: 0 | 4 | 6;
+    } | undefined) => Promise<{
+        address: string;
+        family: 0 | 4 | 6;
+    }[] | {
+        address: string;
+        family: 0 | 4 | 6;
+    } | undefined>;
+    readonly setOverlayHost: (push: (state: {
+        modal: boolean;
+        rects: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        }[];
+    }) => unknown) => Promise<void>;
+    readonly showInstallPrompt: (reason?: string | undefined) => Promise<void>;
+    readonly hideInstallPrompt: () => Promise<void>;
+}>;

package/lib/auto.d.ts

@@ -0,0 +1,5 @@
+export declare const isExtensionAvailable: () => boolean;
+export declare const fetch: (input: RequestInfo | URL, init?: RequestInit & {
+    reason?: string;
+    render?: boolean;
+}) => Promise<Response>;

package/lib/cloud/dgram.d.ts

@@ -0,0 +1,2 @@
+export * from '../webvpn/dgram';
+export { default } from '../webvpn/dgram';

package/lib/cloud/dns.d.ts

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

package/lib/cloud/frame.d.ts

@@ -0,0 +1,3 @@
+import type { AttachFrameOptions, Frame } from '@mfkn/web-extension';
+export declare const attachFrame: ({ iframe, domains, syncCookies, lockdown }: AttachFrameOptions) => Promise<Frame>;
+export declare const available: () => boolean;

package/lib/cloud/fs-promises.d.ts

@@ -0,0 +1,5 @@
+export declare const readFile: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").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?: import("../node-fs/shared").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<import("./fs").Stats>, lstat: (path: import("node:fs").PathLike) => Promise<import("./fs").Stats>, access: (path: import("node:fs").PathLike) => Promise<void>;

package/lib/cloud/fs.d.ts

@@ -0,0 +1,22 @@
+export type { Stats } from '../node-fs';
+export { quota } from '../storage';
+export type { FileEntry, StorageQuota } from '../storage';
+export declare const available: () => Promise<boolean>, readFile: (path: import("node:fs").PathLike, a: import("../node-fs/shared").ReadOptions | import("../node-fs/shared").Callback<Buffer | string>, b?: import("../node-fs/shared").Callback<Buffer | string>) => void, writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, a: import("../node-fs/shared").WriteOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, unlink: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void, readdir: (path: import("node:fs").PathLike, a: unknown, b?: import("../node-fs/shared").Callback<string[]>) => void, mkdir: (path: import("node:fs").PathLike, a: import("../node-fs/shared").MakeOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, rm: (path: import("node:fs").PathLike, a: {
+    recursive?: boolean;
+} | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, stat: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<import("./fs").Stats>) => void, promises: {
+    readFile: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").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?: import("../node-fs/shared").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<import("./fs").Stats>;
+    lstat: (path: import("node:fs").PathLike) => Promise<import("./fs").Stats>;
+    access: (path: import("node:fs").PathLike) => Promise<void>;
+};

package/lib/cloud/http.d.ts

@@ -0,0 +1,2 @@
+export * from '../webvpn/http';
+export { default } from '../webvpn/http';

package/lib/cloud/net.d.ts

@@ -0,0 +1,2 @@
+export * from '../webvpn/net';
+export { default } from '../webvpn/net';

package/lib/cloud.d.ts

@@ -0,0 +1,10 @@
+export { cloudFetch as fetch } from './proxy';
+export { attachFrame } from './cloud/frame';
+export { quota } from './quota';
+export type { QuotaStatus } from './quota';
+export * as dns from './dns';
+export * as fs from './cloud/fs';
+export * as net from './webvpn/net';
+export * as dgram from './webvpn/dgram';
+export * as http from './webvpn/http';
+export declare const available: () => boolean;

package/lib/connect-button.d.ts

@@ -0,0 +1 @@
+export declare const connectButtonUrl: (origin?: string) => string;

package/lib/connect.d.ts

@@ -0,0 +1 @@
+export declare const connect: () => Promise<boolean>;

package/{desktop.d.ts → lib/desktop.d.ts}

@@ -1,17 +1,17 @@
-declare const available: () => boolean;
-declare const fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
-declare const dns: {
+export declare const available: () => boolean;
+export declare const fetch: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare const dns: {
     lookup: (..._args: unknown[]) => never;
 };
-declare const net: {
+export declare const net: {
     connect: (..._args: unknown[]) => never;
     createConnection: (..._args: unknown[]) => never;
     createServer: (..._args: unknown[]) => never;
 };
-declare const dgram: {
+export declare const dgram: {
     createSocket: (..._args: unknown[]) => never;
 };
-declare const fs: {
+export declare const fs: {
     available: () => Promise<boolean>;
     readFile: (..._args: unknown[]) => never;
     readFileSync: (..._args: unknown[]) => never;
@@ -45,5 +45,3 @@ declare const fs: {
         stat: (..._args: unknown[]) => never;
     };
 };
-
-export { available, dgram, dns, fetch, fs, net };

package/lib/dns.d.ts

@@ -0,0 +1,6 @@
+import type { AddressLookupResult } from '../api/dns';
+export type { AddressLookupResult } from '../api/dns';
+export declare const lookup: <T extends boolean = false>(hostname: string, options?: {
+    all?: T;
+    family?: 0 | 4 | 6;
+}) => Promise<T extends true ? AddressLookupResult[] : AddressLookupResult | undefined>;

package/lib/dom.d.ts

@@ -0,0 +1,2 @@
+export declare const iframe: HTMLIFrameElement | null;
+export declare const targetWindow: Window | null;

package/lib/extension-prompt.d.ts

@@ -0,0 +1 @@
+export declare const promptInstall: (reason?: string) => Promise<boolean>;

package/lib/extension.d.ts

@@ -0,0 +1,4 @@
+export * from '@mfkn/web-extension';
+export { extension as events } from '@mfkn/web-extension';
+export { promptInstall } from './extension-prompt';
+export { isExtensionAvailable as available } from './auto';

package/lib/fkn-target.d.ts

@@ -0,0 +1 @@
+export declare const assertNotFknTarget: (input: RequestInfo | URL) => void;

package/lib/frame.d.ts

@@ -0,0 +1,2 @@
+import type { AttachFrameOptions, Frame } from '@mfkn/web-extension';
+export declare const attachFrame: (options: AttachFrameOptions) => Promise<Frame>;

package/lib/fs/content-type.d.ts

@@ -0,0 +1 @@
+export declare const resolveContentType: (path: string, override?: string) => string | undefined;

package/lib/fs/hybrid.d.ts

@@ -0,0 +1,10 @@
+import type { FileEntry, WriteData } from './types';
+export type { FileEntry, FileSystem, WriteData } from './types';
+export declare const available: () => Promise<boolean>;
+export declare const list: () => Promise<FileEntry[]>;
+export declare const readFile: (path: string) => Promise<Blob>;
+export declare const writeFile: (path: string, data: WriteData, opts?: {
+    contentType?: string;
+}) => Promise<void>;
+export declare const remove: (path: string) => Promise<void>;
+export declare const pull: (path: string) => Promise<Blob>;

package/lib/fs/index.d.ts

@@ -0,0 +1,87 @@
+import * as hybrid from './hybrid';
+export type { Stats } from '../node-fs';
+export declare const available: () => Promise<boolean>, readFileSync: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Buffer | string, writeFileSync: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => void, appendFileSync: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => void, existsSync: (path: import("node:fs").PathLike) => boolean, statSync: (path: import("node:fs").PathLike) => import(".").Stats, lstatSync: (path: import("node:fs").PathLike) => import(".").Stats, readdirSync: (path: import("node:fs").PathLike) => string[], mkdirSync: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").MakeOptions) => void, rmSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+}) => void, rmdirSync: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+}) => void, unlinkSync: (path: import("node:fs").PathLike) => void, renameSync: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => void, readFile: (path: import("node:fs").PathLike, a: import("../node-fs/shared").ReadOptions | import("../node-fs/shared").Callback<Buffer | string>, b?: import("../node-fs/shared").Callback<Buffer | string>) => void, writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, a: import("../node-fs/shared").WriteOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, appendFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, a: import("../node-fs/shared").WriteOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, stat: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<import(".").Stats>) => void, readdir: (path: import("node:fs").PathLike, a: unknown, b?: import("../node-fs/shared").Callback<string[]>) => void, mkdir: (path: import("node:fs").PathLike, a: import("../node-fs/shared").MakeOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, rm: (path: import("node:fs").PathLike, a: {
+    recursive?: boolean;
+    force?: boolean;
+} | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void, unlink: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void, rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void, exists: (path: import("node:fs").PathLike, callback: (exists: boolean) => void) => void, promises: {
+    readFile: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Promise<Buffer | string>;
+    writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => Promise<void>;
+    appendFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => Promise<void>;
+    stat: (path: import("node:fs").PathLike) => Promise<import(".").Stats>;
+    lstat: (path: import("node:fs").PathLike) => Promise<import(".").Stats>;
+    readdir: (path: import("node:fs").PathLike) => Promise<string[]>;
+    mkdir: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").MakeOptions) => Promise<void>;
+    rm: (path: import("node:fs").PathLike, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => Promise<void>;
+    rmdir: (path: import("node:fs").PathLike, options?: {
+        recursive?: boolean;
+    }) => Promise<void>;
+    unlink: (path: import("node:fs").PathLike) => Promise<void>;
+    rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>;
+    access: (path: import("node:fs").PathLike) => Promise<void>;
+}, mount: () => Promise<void>, flush: () => Promise<void>, remount: () => Promise<void>;
+export declare const pull: typeof hybrid.pull;
+declare const _default: {
+    available: () => Promise<boolean>;
+    readFileSync: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Buffer | string;
+    writeFileSync: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => void;
+    appendFileSync: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => void;
+    existsSync: (path: import("node:fs").PathLike) => boolean;
+    statSync: (path: import("node:fs").PathLike) => import(".").Stats;
+    lstatSync: (path: import("node:fs").PathLike) => import(".").Stats;
+    readdirSync: (path: import("node:fs").PathLike) => string[];
+    mkdirSync: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").MakeOptions) => void;
+    rmSync: (path: import("node:fs").PathLike, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }) => void;
+    rmdirSync: (path: import("node:fs").PathLike, options?: {
+        recursive?: boolean;
+    }) => void;
+    unlinkSync: (path: import("node:fs").PathLike) => void;
+    renameSync: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => void;
+    readFile: (path: import("node:fs").PathLike, a: import("../node-fs/shared").ReadOptions | import("../node-fs/shared").Callback<Buffer | string>, b?: import("../node-fs/shared").Callback<Buffer | string>) => void;
+    writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, a: import("../node-fs/shared").WriteOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void;
+    appendFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, a: import("../node-fs/shared").WriteOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void;
+    stat: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<import(".").Stats>) => void;
+    readdir: (path: import("node:fs").PathLike, a: unknown, b?: import("../node-fs/shared").Callback<string[]>) => void;
+    mkdir: (path: import("node:fs").PathLike, a: import("../node-fs/shared").MakeOptions | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void;
+    rm: (path: import("node:fs").PathLike, a: {
+        recursive?: boolean;
+        force?: boolean;
+    } | import("../node-fs/shared").Callback<void>, b?: import("../node-fs/shared").Callback<void>) => void;
+    unlink: (path: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void;
+    rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike, callback: import("../node-fs/shared").Callback<void>) => void;
+    exists: (path: import("node:fs").PathLike, callback: (exists: boolean) => void) => void;
+    promises: {
+        readFile: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Promise<Buffer | string>;
+        writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => Promise<void>;
+        appendFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => Promise<void>;
+        stat: (path: import("node:fs").PathLike) => Promise<import(".").Stats>;
+        lstat: (path: import("node:fs").PathLike) => Promise<import(".").Stats>;
+        readdir: (path: import("node:fs").PathLike) => Promise<string[]>;
+        mkdir: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").MakeOptions) => Promise<void>;
+        rm: (path: import("node:fs").PathLike, options?: {
+            recursive?: boolean;
+            force?: boolean;
+        }) => Promise<void>;
+        rmdir: (path: import("node:fs").PathLike, options?: {
+            recursive?: boolean;
+        }) => Promise<void>;
+        unlink: (path: import("node:fs").PathLike) => Promise<void>;
+        rename: (from: import("node:fs").PathLike, to: import("node:fs").PathLike) => Promise<void>;
+        access: (path: import("node:fs").PathLike) => Promise<void>;
+    };
+    mount: () => Promise<void>;
+    flush: () => Promise<void>;
+    remount: () => Promise<void>;
+    pull: typeof hybrid.pull;
+};
+export default _default;

package/lib/fs/opfs.d.ts

@@ -0,0 +1,8 @@
+import type { FileEntry, WriteData } from './types';
+export declare const available: () => Promise<boolean>;
+export declare const writeFile: (path: string, data: WriteData, opts?: {
+    contentType?: string;
+}) => Promise<void>;
+export declare const readFile: (path: string) => Promise<Blob>;
+export declare const remove: (path: string) => Promise<void>;
+export declare const list: () => Promise<FileEntry[]>;

package/lib/fs/promises.d.ts

@@ -0,0 +1,8 @@
+import { promises } from './index';
+export declare const readFile: (path: import("node:fs").PathLike, options?: import("../node-fs/shared").ReadOptions) => Promise<Buffer | string>, writeFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").WriteOptions) => Promise<void>, appendFile: (path: import("node:fs").PathLike, data: import("../node-fs/shared").WriteData, options?: import("../node-fs/shared").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?: import("../node-fs/shared").MakeOptions) => Promise<void>, rm: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+    force?: boolean;
+}) => Promise<void>, rmdir: (path: import("node:fs").PathLike, options?: {
+    recursive?: boolean;
+}) => Promise<void>, stat: (path: import("node:fs").PathLike) => Promise<import("./index").Stats>, lstat: (path: import("node:fs").PathLike) => Promise<import("./index").Stats>, access: (path: import("node:fs").PathLike) => Promise<void>;
+export default promises;

package/lib/fs/types.d.ts

@@ -0,0 +1,16 @@
+export type FileEntry = {
+    path: string;
+    size: number;
+    contentType: string | null;
+    updatedAt: string | null;
+};
+export type WriteData = Blob | ArrayBuffer | Uint8Array | string;
+export type FileSystem = {
+    available: () => Promise<boolean>;
+    list: () => Promise<FileEntry[]>;
+    readFile: (path: string) => Promise<Blob>;
+    writeFile: (path: string, data: WriteData, opts?: {
+        contentType?: string;
+    }) => Promise<void>;
+    remove: (path: string) => Promise<void>;
+};

package/lib/index.d.ts

@@ -0,0 +1,18 @@
+export * from '@mfkn/web-extension';
+export * as cloud from './cloud';
+export * as extension from './extension';
+export * as desktop from './desktop';
+export { fetch } from './auto';
+export * as dns from './dns';
+export * as fs from './fs';
+export * as opfs from './opfs';
+export * as net from './webvpn/net';
+export * as dgram from './webvpn/dgram';
+export * as http from './webvpn/http';
+export { attachFrame } from './frame';
+export { relayWorker } from './relay';
+export * as packages from './packages';
+export { promptInstall } from './extension-prompt';
+export { connect } from './connect';
+export * as account from './account';
+export { connectButtonUrl } from './connect-button';