sliftutils 1.7.5 → 1.7.7

package/index.d.ts

@@ -1879,6 +1879,7 @@ declare module "sliftutils/storage/FileFolderAPI" {
         [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
     };
     export declare function setFileAPIKey(key: string): void;
+    export declare function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void;
     export declare class NodeJSFileHandleWrapper implements FileWrapper {
         private filePath;
         constructor(filePath: string);
@@ -1968,6 +1969,47 @@ declare module "sliftutils/storage/FileFolderAPI" {
 
 }
 
+declare module "sliftutils/storage/IArchives" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type ArchiveFileInfo = {
+        path: string;
+        createTime: number;
+        size: number;
+    };
+    export interface IArchives {
+        getDebugName(): string;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        /** Only works for public buckets (private buckets are API-access only). */
+        getURL(path: string): Promise<string>;
+    }
+
+}
+
 declare module "sliftutils/storage/IStorage" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -2224,7 +2266,8 @@ declare module "sliftutils/storage/TransactionStorage" {
 declare module "sliftutils/storage/backblaze" {
     /// <reference types="node" />
     /// <reference types="node" />
-    export declare class ArchivesBackblaze {
+    import { IArchives } from "./IArchives";
+    export declare class ArchivesBackblaze implements IArchives {
         private config;
         constructor(config: {
             bucketName: string;
@@ -2380,6 +2423,7 @@ declare module "sliftutils/storage/fileSystemPointer" {
         handle: FileSystemFileHandle | FileSystemDirectoryHandle;
     }): Promise<FileSystemPointer>;
     export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+    export declare function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined>;
     export declare function getFileSystemPointer(config: {
         pointer: FileSystemPointer;
     }): Promise<{
@@ -2527,6 +2571,240 @@ declare module "sliftutils/storage/remoteFileStorage" {
 
 }
 
+declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IArchives, ArchiveFileInfo } from "../IArchives";
+    export type ArchivesRemoteConfig = {
+        address: string;
+        port: number;
+        account: string;
+        bucketName: string;
+        public?: boolean;
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export declare function buildPublicFileURL(config: {
+        address: string;
+        port: number;
+        account: string;
+        bucketName: string;
+        path: string;
+    }): string;
+    export declare function authenticateStorage(config: {
+        address: string;
+        port: number;
+        nodeId: string;
+    }): Promise<{
+        machineId: string;
+        ip: string;
+    }>;
+    export declare class ArchivesRemote implements IArchives {
+        private config;
+        constructor(config: ArchivesRemoteConfig);
+        private nodeId;
+        private controller;
+        private setupDone;
+        private lastDeniedLog;
+        getDebugName(): string;
+        private authenticate;
+        private callAuthed;
+        waitingForAccess(): Promise<string | undefined>;
+        private onAccessDenied;
+        private ensureSetup;
+        private call;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getURL(path: string): Promise<string>;
+    }
+
+}
+
+declare module "sliftutils/storage/remoteStorage/accessPage" {
+    export {};
+
+}
+
+declare module "sliftutils/storage/remoteStorage/blobStore" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { ArchiveFileInfo } from "../IArchives";
+    export declare const DEFAULT_FAST_WRITE_DELAY: number;
+    export type WriteConfig = {
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export declare class BlobStore {
+        private folder;
+        constructor(folder: string);
+        private memCache;
+        private overlay;
+        private writeQueue;
+        private openBlobs;
+        private largeUploads;
+        private nextLargeUploadId;
+        private currentBlobNumber;
+        private currentBlobOffset;
+        private currentBlobFd;
+        private index;
+        private deadBytes;
+        private blobsDir;
+        init: {
+            (): Promise<void>;
+            reset(): void;
+            set(newValue: Promise<void>): void;
+        };
+        private blobName;
+        private blobPath;
+        private getBlobHandle;
+        private closeBlobHandle;
+        private addDeadBytes;
+        private appendData;
+        private setIndexEntry;
+        set(key: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        del(key: string, config?: WriteConfig): Promise<void>;
+        get(key: string, range?: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
+        getInfo(key: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        startLargeUpload(): Promise<string>;
+        appendLargeUpload(id: string, data: Buffer): Promise<void>;
+        finishLargeUpload(id: string, key: string): Promise<void>;
+        cancelLargeUpload(id: string): Promise<void>;
+        private flushOverlay;
+        private compact;
+    }
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageController" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { ArchiveFileInfo } from "../IArchives";
+    import type { BlobStore } from "./blobStore";
+    import type { IStorage } from "../IStorage";
+    export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
+    export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
+    export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
+    export declare const STORAGE_ACCESS_DENIED = "REMOTE_STORAGE_ACCESS_DENIED_9d81a4c0";
+    export type AuthToken = {
+        certPem: string;
+        time: number;
+        signature: string;
+    };
+    export type AccessRequest = {
+        requestId: string;
+        account: string;
+        machineId: string;
+        ip: string;
+        time: number;
+    };
+    export type TrustRecord = {
+        account: string;
+        machineId: string;
+        ip: string;
+        time: number;
+    };
+    export type BucketConfig = {
+        public?: boolean;
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export type AccessState = {
+        machineId: string;
+        ip: string;
+        hasAccess: boolean;
+        listAccessCommand: string;
+        grantAccessCommand?: string;
+        machines?: (AccessRequest & {
+            trusted: boolean;
+        })[];
+    };
+    export type StorageServerState = {
+        domain: string;
+        port: number;
+        rootDomain: string;
+        sshTarget: string;
+        serverCommand: string;
+        blobStore: BlobStore;
+        trust: IStorage<TrustRecord>;
+        requests: IStorage<AccessRequest[]>;
+        buckets: IStorage<BucketConfig>;
+    };
+    export declare function setStorageServerState(state: StorageServerState): void;
+    export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+        authenticate: (token: AuthToken) => Promise<{
+            machineId: string;
+            ip: string;
+        }>;
+        requestAccess: (account: string) => Promise<{
+            machineId: string;
+            ip: string;
+            requestId: string;
+            grantAccessCommand: string;
+        }>;
+        getAccessState: (account: string) => Promise<AccessState>;
+        adminListRequests: (ip: string) => Promise<AccessRequest[]>;
+        adminGrantAccess: (requestId: string) => Promise<TrustRecord>;
+        ensureBucket: (account: string, bucketName: string, config: BucketConfig) => Promise<void>;
+        get: (account: string, bucketName: string, path: string, range?: {
+            start: number;
+            end: number;
+        }) => Promise<Buffer | undefined>;
+        set: (account: string, bucketName: string, path: string, data: Buffer) => Promise<void>;
+        del: (account: string, bucketName: string, path: string) => Promise<void>;
+        getInfo: (account: string, bucketName: string, path: string) => Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo: (account: string, bucketName: string, prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }) => Promise<ArchiveFileInfo[]>;
+        startLargeFile: (account: string, bucketName: string, path: string) => Promise<string>;
+        uploadPart: (uploadId: string, data: Buffer) => Promise<void>;
+        finishLargeFile: (uploadId: string) => Promise<void>;
+        cancelLargeFile: (uploadId: string) => Promise<void>;
+        getPublicFile: (account: string, bucketName: string, path: string) => Promise<Buffer>;
+    }>;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageServer" {
+    import "./accessPage";
+
+}
+
 declare module "sliftutils/storage/storage" {
 
 

package/misc/https/persistentLocalStorage.ts

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import { isNode } from "socket-function/src/misc";
 import fs from "fs";
 import os from "os";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.5",
+    "version": "1.7.7",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/render-utils/Input.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import preact from "preact";
 import { css } from "typesafecss";
 import { observer } from "./observer";

package/render-utils/InputLabel.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import preact from "preact";
 import { Input } from "./Input";
 import { css } from "typesafecss";

package/render-utils/colors.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import { css } from "typesafecss";
 
 export const redButton = css.hsl(0, 75, 50).bord(1, "hsl(0, 75%, 75%)").background("hsl(0, 75%, 75%)", "hover") as string;

package/storage/BulkDatabase2/syncClient.ts

@@ -1,10 +1,9 @@
-import { isNode } from "typesafecss";
-
 // Browser-side cross-tab write sync for BulkDatabase2, over BroadcastChannel (one channel per
-// collection, same-origin tabs). It does NOT persist anything — each tab writes to disk itself; this
-// just relays live writes to other open tabs and, when a tab starts up, asks peers for writes they've
-// made recently that may not be on disk yet. No-op in Node / where BroadcastChannel is unavailable, so
-// BulkDatabase2 can call these unconditionally. This is an optional feature, so there is no fallback.
+// collection, same-origin tabs and workers). It does NOT persist anything — each side writes to disk
+// itself; this just relays live writes to other open tabs/workers and, when one starts up, asks peers
+// for writes they've made recently that may not be on disk yet. No-op in Node / where
+// BroadcastChannel is unavailable, so BulkDatabase2 can call these unconditionally. This is an
+// optional feature, so there is no fallback.
 
 export type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };
 
@@ -24,7 +23,11 @@ type Channel = {
 const channels = new Map<string, Channel>();
 
 export function isSyncSupported(): boolean {
-    return !isNode() && typeof BroadcastChannel !== "undefined";
+    // window (main-thread browser) or WorkerGlobalScope (Web/Service/Shared worker) — but not Node
+    // (typesafecss's isNode is `typeof window === "undefined"`, which misclassifies workers)
+    let isBrowserOrWorker = typeof window !== "undefined"
+        || "WorkerGlobalScope" in globalThis;
+    return isBrowserOrWorker && typeof BroadcastChannel !== "undefined";
 }
 
 function pruneRecent(channel: Channel) {

package/storage/FileFolderAPI.d.ts

@@ -66,6 +66,7 @@ export type DirectoryWrapper = {
     [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
 };
 export declare function setFileAPIKey(key: string): void;
+export declare function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void;
 export declare class NodeJSFileHandleWrapper implements FileWrapper {
     private filePath;
     constructor(filePath: string);

package/storage/FileFolderAPI.tsx

@@ -1,5 +1,5 @@
 import preact from "preact";
-import { getFileSystemPointer, storeFileSystemPointer } from "./fileSystemPointer";
+import { findGrantedPointerHandle, getFileSystemPointer, storeFileSystemPointer } from "./fileSystemPointer";
 import { observable } from "mobx";
 import { observer } from "../render-utils/observer";
 import { cache, lazy } from "socket-function/src/caching";
@@ -36,6 +36,9 @@ declare global {
 // DO NOT enable this is isNode
 const USE_INDEXED_DB = false;
 
+// How often a worker rechecks the pointer IndexedDB for a granted handle when none is available yet.
+const WORKER_POLL_INTERVAL_MS = 60 * 1000;
+
 // These mirror the subset of the native FileSystemFileHandle / FileSystemDirectoryHandle API we use, so
 // the native browser handles, the Node handles, and the remote handles are all interchangeable — and
 // code written against the native handle (e.g. a recursive walk over `handle.entries()`) works on any of
@@ -91,6 +94,18 @@ export function setFileAPIKey(key: string) {
     fileAPIKey = key;
 }
 
+// A directory handle to serve as the storage root instead of resolving one via
+// the picker / stored-pointer / remote flow. Set this in a context that can't run
+// the interactive resolution — most importantly a Web Worker, which has no DOM to
+// prompt with and no localStorage pointer. The owning window resolves the handle
+// (with its permission grant) and postMessages it in; the worker calls this before
+// touching any storage. When set, getDirectoryHandle returns it directly and skips
+// every DOM / localStorage branch below.
+let storageRootOverride: FileSystemDirectoryHandle | undefined;
+export function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void {
+    storageRootOverride = handle;
+}
+
 // ---- remote (server) storage config ----
 // Instead of a local folder, the user can point at a remoteFileServer.js instance (URL + password).
 // When configured, getFileStorageNested2 serves everything from that server. Persisted in localStorage.
@@ -442,6 +457,26 @@ export function pickPrivateFolder(name: string): void {
 // (we actually connect) before use; if it no longer works we re-prompt, just like a local folder whose
 // permission was lost. Blocks until ready (or the user dismisses, which rejects).
 export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
+    // An injected root (e.g. a Web Worker handed the handle by its owning window)
+    // short-circuits the whole interactive resolution — no picker, no DOM, no
+    // localStorage. Must come first so a worker never reaches the branches below.
+    if (storageRootOverride) {
+        return storageRootOverride as unknown as DirectoryWrapper;
+    }
+    // A worker can't show the picker (no DOM / no user activation) and can't read localStorage, but
+    // it CAN open the pointer IndexedDB the main-thread picker persists to. Poll it for a handle
+    // whose permission is already granted; the owning window may also postMessage a handle in
+    // mid-poll (checked each iteration). This has to come before the isNode branch: typesafecss's
+    // isNode() returns true in workers (window is undefined), so a worker would otherwise fall into
+    // the Node branch and try to use fs/path.
+    if ("WorkerGlobalScope" in globalThis) {
+        while (true) {
+            if (storageRootOverride) return storageRootOverride as unknown as DirectoryWrapper;
+            let handle = await findGrantedPointerHandle("readwrite");
+            if (handle) return handle as unknown as DirectoryWrapper;
+            await new Promise(resolve => setTimeout(resolve, WORKER_POLL_INTERVAL_MS));
+        }
+    }
     if (isNode()) {
         return new NodeJSDirectoryHandleWrapper(path.resolve("./data/"));
     }

package/storage/IArchives.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type ArchiveFileInfo = {
+    path: string;
+    createTime: number;
+    size: number;
+};
+export interface IArchives {
+    getDebugName(): string;
+    get(fileName: string, config?: {
+        range?: {
+            start: number;
+            end: number;
+        };
+    }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+    setLargeFile(config: {
+        path: string;
+        getNextData(): Promise<Buffer | undefined>;
+    }): Promise<void>;
+    getInfo(fileName: string): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    find(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<string[]>;
+    findInfo(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<ArchiveFileInfo[]>;
+    /** Only works for public buckets (private buckets are API-access only). */
+    getURL(path: string): Promise<string>;
+}

package/storage/IArchives.ts

@@ -0,0 +1,20 @@
+module.allowclient = true;
+
+// The important operations of an archive bucket (extracted from ArchivesBackblaze), so other
+// backends (e.g. our own remote storage server) can be used interchangeably.
+
+export type ArchiveFileInfo = { path: string; createTime: number; size: number };
+
+export interface IArchives {
+    getDebugName(): string;
+    get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+    setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void>;
+    getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined>;
+    find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]>;
+    findInfo(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<ArchiveFileInfo[]>;
+    /** Only works for public buckets (private buckets are API-access only). */
+    getURL(path: string): Promise<string>;
+}

package/storage/backblaze.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-export declare class ArchivesBackblaze {
+import { IArchives } from "./IArchives";
+export declare class ArchivesBackblaze implements IArchives {
     private config;
     constructor(config: {
         bucketName: string;

package/storage/backblaze.ts

@@ -9,6 +9,7 @@ import debugbreak from "debugbreak";
 import dns from "dns";
 import { getSecret } from "../misc/getSecret";
 import { httpsRequest } from "socket-function/src/https";
+import { IArchives } from "./IArchives";
 
 type BackblazeCreds = {
     applicationKeyId: string;
@@ -372,7 +373,7 @@ const getAPI = lazy(async () => {
 type B2Api = (typeof getAPI) extends () => Promise<infer T> ? T : never;
 
 
-export class ArchivesBackblaze {
+export class ArchivesBackblaze implements IArchives {
     public constructor(private config: {
         bucketName: string;
         public?: boolean;

package/storage/fileSystemPointer.d.ts

@@ -4,6 +4,7 @@ export declare function storeFileSystemPointer(config: {
     handle: FileSystemFileHandle | FileSystemDirectoryHandle;
 }): Promise<FileSystemPointer>;
 export declare function deleteFileSystemPointer(pointer: FileSystemPointer): Promise<void>;
+export declare function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined>;
 export declare function getFileSystemPointer(config: {
     pointer: FileSystemPointer;
 }): Promise<{

package/storage/fileSystemPointer.ts

@@ -55,6 +55,36 @@ export async function deleteFileSystemPointer(pointer: FileSystemPointer) {
     });
 }
 
+// Enumerates every stored pointer handle whose permission is already granted for `mode`, newest first
+// (pointer keys start with Date.now(), which sorts lexicographically). Callable from a Web Worker —
+// unlike getFileSystemPointer's onUserActivation flow, this only uses queryPermission, which does
+// NOT require user activation.
+export async function findGrantedPointerHandle(mode: "read" | "readwrite"): Promise<FileSystemDirectoryHandle | undefined> {
+    let database = await db();
+    if (!database) return undefined;
+    let store = database.transaction(objectStoreName, "readonly").objectStore(objectStoreName);
+    let keysReq = store.getAllKeys();
+    let valuesReq = store.getAll();
+    await new Promise((resolve, reject) => {
+        keysReq.addEventListener("success", resolve);
+        keysReq.addEventListener("error", reject);
+    });
+    await new Promise((resolve, reject) => {
+        valuesReq.addEventListener("success", resolve);
+        valuesReq.addEventListener("error", reject);
+    });
+    let keys = keysReq.result as string[];
+    let values = valuesReq.result as (FileSystemFileHandle | FileSystemDirectoryHandle)[];
+    let entries = keys.map((key, i) => ({ key, value: values[i], time: +key.split("_")[0] || 0 }))
+        .sort((a, b) => b.time - a.time);
+    for (let entry of entries) {
+        if (entry.value.kind !== "directory") continue;
+        let state = await (entry.value as any).queryPermission({ mode });
+        if (state === "granted") return entry.value;
+    }
+    return undefined;
+}
+
 export async function getFileSystemPointer(config: {
     pointer: FileSystemPointer;
 }): Promise<{

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IArchives, ArchiveFileInfo } from "../IArchives";
+export type ArchivesRemoteConfig = {
+    address: string;
+    port: number;
+    account: string;
+    bucketName: string;
+    public?: boolean;
+    fast?: boolean;
+    writeDelay?: number;
+};
+export declare function buildPublicFileURL(config: {
+    address: string;
+    port: number;
+    account: string;
+    bucketName: string;
+    path: string;
+}): string;
+export declare function authenticateStorage(config: {
+    address: string;
+    port: number;
+    nodeId: string;
+}): Promise<{
+    machineId: string;
+    ip: string;
+}>;
+export declare class ArchivesRemote implements IArchives {
+    private config;
+    constructor(config: ArchivesRemoteConfig);
+    private nodeId;
+    private controller;
+    private setupDone;
+    private lastDeniedLog;
+    getDebugName(): string;
+    private authenticate;
+    private callAuthed;
+    waitingForAccess(): Promise<string | undefined>;
+    private onAccessDenied;
+    private ensureSetup;
+    private call;
+    get(fileName: string, config?: {
+        range?: {
+            start: number;
+            end: number;
+        };
+    }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    getInfo(fileName: string): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    findInfo(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<ArchiveFileInfo[]>;
+    find(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<string[]>;
+    setLargeFile(config: {
+        path: string;
+        getNextData(): Promise<Buffer | undefined>;
+    }): Promise<void>;
+    getURL(path: string): Promise<string>;
+}