@visulima/storage 1.0.9 → 1.0.10

package/dist/packem_shared/files.d-CH0iLBNC.d.ts

@@ -1,655 +0,0 @@
-import { B as BaseStorage, O as OperationOptions } from "./storage.d-CEM1upWM.js";
-import { Readable } from 'node:stream';
-/**
-* Pause / resume / abort handle threaded into {@link Files.upload} via {@link UploadOptions.control}.
-*
-* `pause()` applies backpressure to the body stream; `resume()` releases it. This is effective for
-* streaming bodies feeding streaming adapters (S3, GCS, Azure, FTP/SFTP). Buffered adapters
-* (memory, disk) read the whole body in one shot and cannot be paused mid-transfer.
-* `abort()` cancels the operation through the merged {@link OperationOptions.signal}.
-* `serialize()` / {@link UploadControl.from} round-trip the key + bytes observed for UI continuity.
-* @example
-* ```ts
-* const control = new UploadControl();
-* const promise = files.upload("big.bin", stream, { size, control });
-* pauseButton.onclick = () => control.pause();
-* resumeButton.onclick = () => control.resume();
-* cancelButton.onclick = () => control.abort();
-* await promise;
-* ```
-*/
-declare class UploadControl {
-  /** Caller-facing key being uploaded; populated once the upload starts. */
-  key?: string;
-  private readonly controller;
-  private internalState;
-  private loadedBytes;
-  private startPaused;
-  private boundStream?;
-  constructor(initial?: {
-    key?: string;
-    loaded?: number;
-  });
-  /**
-  * Rehydrate a control from a {@link serialize} token (object or JSON string). The returned
-  * control is `idle` with its `loaded` counter pre-seeded for progress display.
-  */
-  static from(token: UploadControlToken | string): UploadControl;
-  /** Abort signal merged into the upload operation. */
-  get signal(): AbortSignal;
-  get state(): UploadControlState;
-  /** Bytes observed leaving the facade so far. */
-  get loaded(): number;
-  pause(): void;
-  resume(): void;
-  abort(reason?: unknown): void;
-  serialize(): UploadControlToken;
-}
-/**
-* Web-standard and Node-native body types accepted by {@link Files.upload}.
-*/
-type FileBody = ArrayBuffer | ArrayBufferView | Blob | Buffer | NodeJS.ReadableStream | ReadableStream<Uint8Array> | string;
-/**
-* Byte range for {@link Files.download}. Both bounds are 0-based and `end` is
-* **inclusive**, mirroring the HTTP `Range: bytes=start-end` header. Omit `end`
-* to read from `start` to EOF (e.g. resume an interrupted download).
-*/
-interface DownloadRange {
-  end?: number;
-  start: number;
-}
-/**
-* Realtime upload progress report. `total` is omitted for streaming bodies of
-* unknown length. The optional `key` is set on the bulk array form so a single
-* callback can drive a multi-row UI.
-*/
-interface UploadProgress {
-  key?: string;
-  loaded: number;
-  total?: number;
-}
-type UploadProgressCallback = (event: UploadProgress) => void;
-/** Lifecycle state of an {@link UploadControl}. */
-type UploadControlState = "aborted" | "completed" | "idle" | "paused" | "uploading";
-/**
-* Serializable snapshot of an {@link UploadControl}, returned by {@link UploadControl.serialize}
-* and accepted by {@link UploadControl.from}. Captures the key and bytes observed so a UI can
-* restore progress display across reloads. Note: byte-accurate *resume* of the transfer itself is
-* a protocol concern handled by the TUS / multipart handlers and `@visulima/storage-client`; a
-* rehydrated control restarts the body from the beginning.
-*/
-interface UploadControlToken {
-  key?: string;
-  loaded: number;
-  version: 1;
-}
-/**
-* Multipart tuning for {@link Files.upload}. `true` enables multipart with
-* adapter defaults; an object lets the caller tune the per-part size and the
-* number of parts uploaded in parallel.
-*/
-interface MultipartOptions {
-  /** In-flight parts. Adapter-defined default. */
-  concurrency?: number;
-  /** Per-part size in bytes. Adapter-defined default. */
-  partSize?: number;
-}
-interface UploadOptions {
-  /**
-  * Pre-computed content integrity checksum for end-to-end verification. Adapters that verify
-  * checksums on write (e.g. DiskStorage, TUS) reject the upload when the stored bytes don't
-  * match. Pair with {@link UploadOptions.checksumAlgorithm} to select the digest; defaults to
-  * the adapter's preferred algorithm when omitted. Ignored by adapters without checksum support.
-  */
-  checksum?: string;
-  /**
-  * Digest algorithm for {@link UploadOptions.checksum} (e.g. `"sha256"`, `"md5"`, `"crc32c"`).
-  * Adapter-dependent; ignored when no `checksum` is supplied.
-  */
-  checksumAlgorithm?: string;
-  contentType?: string;
-  /**
-  * Pause / resume / abort handle for this upload. Pausing applies backpressure to the body
-  * stream (effective for streaming bodies and streaming adapters; buffered adapters consume the
-  * whole body at once and cannot be paused mid-flight); aborting cancels the operation via the
-  * merged {@link OperationOptions.signal}. See {@link UploadControl}.
-  */
-  control?: UploadControl;
-  metadata?: Record<string, unknown>;
-  /**
-  * Enable multipart/chunked upload for large bodies. `true` uses the
-  * adapter's defaults; pass an object to tune. Adapters that don't have a
-  * multipart primitive ignore this option.
-  */
-  multipart?: MultipartOptions | boolean;
-  /**
-  * Realtime progress reporter. For buffered bodies a coarse start/done pair
-  * is emitted. For streaming bodies each chunk is reported as it leaves the
-  * facade. Adapters that report progress natively (`reportsUploadProgress`)
-  * supersede this with byte-accurate events. A throwing callback can never
-  * fail the upload — exceptions are swallowed.
-  */
-  onProgress?: UploadProgressCallback;
-  /**
-  * Explicit byte length. Required for {@link NodeJS.ReadableStream} and Web `ReadableStream`
-  * inputs because their length is not derivable from the value itself; ignored otherwise.
-  */
-  size?: number;
-  storageClass?: string;
-}
-interface SignedReadUrlOptions {
-  expiresIn?: number;
-  responseContentDisposition?: string;
-  responseContentType?: string;
-}
-interface SignedUploadUrlOptions {
-  contentLength?: number;
-  contentType?: string;
-  expiresIn?: number;
-}
-interface ListOptions {
-  /**
-  * Collapse keys that share a path segment into S3-style common prefixes ("directories").
-  * When set, {@link Files.list} returns a {@link ListDirectoryResult} (`{ files, prefixes }`)
-  * instead of a flat array: keys with no further `delimiter` after the listing prefix come back
-  * as `files`, and everything below a shared boundary is folded into a single `prefixes` entry.
-  * Pass `"/"` for conventional folder semantics.
-  */
-  delimiter?: string;
-  limit?: number;
-  prefix?: string;
-}
-/**
-* Directory-style listing returned by {@link Files.list} when a `delimiter` is supplied.
-*/
-interface ListDirectoryResult {
-  /** Objects that live directly under the listing prefix (no further delimiter). */
-  files: FileObject[];
-  /** Common prefixes ("subdirectories") one delimiter level below the listing prefix. */
-  prefixes: string[];
-}
-interface ListAllOptions {
-  /** Per-page size requested from the adapter. */
-  limit?: number;
-  prefix?: string;
-}
-/**
-* Capability snapshot for the adapter behind a {@link Files} instance, surfaced so callers can
-* branch (or fail fast) instead of discovering an unsupported operation mid-flight.
-*/
-interface StorageCapabilities {
-  /** The adapter honours an object `cacheControl` directive on write. */
-  cacheControl: boolean;
-  /** The adapter persists and returns user-supplied key/value metadata. */
-  metadata: boolean;
-  /** The adapter honours byte-range downloads (`download({ range })`). */
-  range: boolean;
-  /** This `Files` view rejects every mutating operation. */
-  readonly: boolean;
-}
-interface DownloadOptions extends OperationOptions {
-  /**
-  * Fetch a contiguous byte slice instead of the whole object. Throws
-  * `METHOD_NOT_ALLOWED` when the underlying adapter has `supportsRange =
-  * false`, so the bandwidth saving is never silently lost client-side.
-  */
-  range?: DownloadRange;
-}
-/**
-* Provider-agnostic metadata-only view of an object.
-*/
-interface FileObject {
-  contentType: string;
-  etag?: string;
-  key: string;
-  lastModified?: Date | number | string;
-  metadata?: Record<string, unknown>;
-  size?: number;
-}
-interface DownloadResult extends FileObject {
-  body: Buffer;
-}
-/**
-* Streaming variant of {@link DownloadResult} returned by {@link Files.downloadStream}. The object
-* body is exposed as a Node {@link NodeJS.ReadableStream} instead of a fully-buffered `Buffer`, so
-* serving a large object never allocates the whole payload in memory. Backed by the adapter's
-* native `getStream()`.
-*/
-interface DownloadStreamResult extends FileObject {
-  body: Readable;
-}
-/**
-* Caller-facing event for {@link FilesOptions.hooks}. Mirrors what runs through
-* the facade (the public `key`/`keys` and the operation type) without leaking
-* adapter internals.
-*/
-interface HookEvent {
-  durationMs?: number;
-  error?: Error;
-  /** Source key for `copy`/`move`. */
-  from?: string;
-  key?: string;
-  keys?: string[];
-  /** Destination key for `copy`/`move`. */
-  to?: string;
-  type: HookActionType;
-}
-type HookActionType = "copy" | "delete" | "download" | "exists" | "head" | "list" | "listAll" | "move" | "signedUploadUrl" | "transfer" | "upload" | "url";
-/**
-* Lifecycle hooks observed by the Files facade. Every hook is fire-and-forget —
-* called, not awaited — and exceptions are swallowed so a hook can never fail
-* the operation it observes.
-*/
-interface FilesHooks {
-  /** Called once per successful operation, with timing and result keys. */
-  onAction?: (event: HookEvent) => void;
-  /** Called once per failed operation, with the error attached. */
-  onError?: (event: HookEvent & {
-    error: Error;
-  }) => void;
-  /**
-  * Called when the underlying adapter retries an operation. Receives the
-  * attempt number (1-based) and the error that triggered the retry.
-  */
-  onRetry?: (event: HookEvent & {
-    attempt: number;
-    error: Error;
-  }) => void;
-}
-interface FilesOptions<TStorage extends BaseStorage = BaseStorage> {
-  adapter: TStorage;
-  /**
-  * Default {@link OperationOptions} (`signal`, `timeout`, `retries`) merged into every call.
-  * Per-call overrides win. The `signal` is combined with any per-call `signal` via
-  * `AbortSignal.any`, so either one aborts the operation.
-  */
-  defaults?: OperationOptions;
-  /**
-  * Lifecycle hooks observed by every operation. Fire-and-forget — a throwing
-  * hook is silently swallowed and never fails the call it observes.
-  */
-  hooks?: FilesHooks;
-  /**
-  * Namespace every key under this prefix. Reads, writes, copies, listings, URLs, and signed
-  * uploads all resolve keys as `${prefix}/${key}`; returned keys (including from `list()`) have
-  * the prefix stripped back off. Leading/trailing slashes are normalized so `"/users/"` and
-  * `"users"` behave identically.
-  *
-  * `list()` scopes results on a path boundary, so `prefix: "users"` never matches the sibling
-  * `users-archive/`.
-  */
-  prefix?: string;
-  /**
-  * When `true`, every mutating operation (`upload`, `delete`, `copy`, `move`, `signedUploadUrl`)
-  * fails immediately with `FilesError { code: "ReadOnly" }` before the adapter is touched; reads
-  * (`download`, `head`, `exists`, `list`, `listAll`, `url`) pass through. Derive a locked view of
-  * an existing client with {@link Files.readonly} instead of threading the flag manually.
-  * @default false
-  */
-  readonly?: boolean;
-}
-/**
-* One item in a bulk upload call.
-*/
-interface BulkUploadItem extends UploadOptions {
-  body: FileBody;
-  key: string;
-}
-/**
-* Per-call options shared by every bulk method (`upload`, `download`, `head`, `exists`, `delete`).
-*/
-interface BulkOptions extends OperationOptions {
-  /**
-  * Maximum number of in-flight operations.
-  * @default 8
-  */
-  concurrency?: number;
-  /**
-  * When `true`, stop dispatching new operations as soon as one fails. The already-issued
-  * operations still complete. Defaults to `false`: every key is attempted and per-key failures
-  * are collected in `errors`.
-  * @default false
-  */
-  stopOnError?: boolean;
-}
-interface BulkDownloadOptions extends BulkOptions {
-  range?: DownloadRange;
-}
-interface BulkUploadOptions extends BulkOptions {
-  multipart?: MultipartOptions | boolean;
-  onProgress?: UploadProgressCallback;
-}
-interface BulkError {
-  error: Error;
-  key: string;
-}
-interface BulkUploadResult {
-  errors?: BulkError[];
-  uploaded: FileObject[];
-}
-interface BulkDownloadResult {
-  downloaded: DownloadResult[];
-  errors?: BulkError[];
-}
-interface BulkHeadResult {
-  errors?: BulkError[];
-  files: FileObject[];
-}
-interface BulkExistsResult {
-  errors?: BulkError[];
-  existing: string[];
-  missing: string[];
-}
-interface BulkDeleteResult {
-  deleted: string[];
-  errors?: BulkError[];
-}
-interface BulkMoveItem {
-  from: string;
-  to: string;
-}
-interface BulkMoveResult {
-  errors?: BulkError[];
-  moved: FileObject[];
-}
-/**
-* Per-key event reported to {@link TransferOptions.onProgress}.
-*/
-interface TransferProgress {
-  /** 1-based index of the current key in walk order. */
-  done: number;
-  error?: Error;
-  key: string;
-  status: "errored" | "skipped" | "transferred";
-}
-interface TransferOptions extends OperationOptions {
-  /**
-  * In-flight key transfers.
-  * @default 8
-  */
-  concurrency?: number;
-  /** Per-page size requested from the source adapter while walking. */
-  limit?: number;
-  /** Fire-and-forget progress reporter. Throws are swallowed. */
-  onProgress?: (event: TransferProgress) => void;
-  /**
-  * When `false`, skip keys that already exist at the destination. When `true`, always upload.
-  * @default false
-  */
-  overwrite?: boolean;
-  /** Restrict the walk to this prefix on the source. */
-  prefix?: string;
-  /**
-  * When `true`, the first failing transfer rejects {@link transfer} instead of being
-  * collected in `errors`.
-  * @default false
-  */
-  stopOnError?: boolean;
-  /** Transform each source key into the destination key. Defaults to identity. */
-  transformKey?: (key: string) => string;
-}
-interface TransferResult {
-  errors?: BulkError[];
-  skipped: string[];
-  transferred: string[];
-}
-/**
-* Per-key event reported to {@link SyncOptions.onProgress}.
-*/
-interface SyncProgress {
-  /** 1-based index of the current key in walk order. */
-  done: number;
-  error?: Error;
-  key: string;
-  status: "deleted" | "errored" | "skipped" | "unchanged" | "updated" | "uploaded";
-}
-interface SyncOptions extends OperationOptions {
-  /**
-  * In-flight key operations.
-  * @default 8
-  */
-  concurrency?: number;
-  /**
-  * Compute the plan without writing anything. The returned `uploaded`/`updated`/`deleted` lists
-  * describe what *would* happen; the destination is left untouched.
-  * @default false
-  */
-  dryRun?: boolean;
-  /** Per-page size requested from the source adapter while walking. */
-  limit?: number;
-  /** Fire-and-forget progress reporter. Throws are swallowed. */
-  onProgress?: (event: SyncProgress) => void;
-  /** Restrict the sync to this prefix on both source and destination. */
-  prefix?: string;
-  /**
-  * Delete destination keys that no longer exist on the source (mirror semantics). Pruning runs
-  * after the copy pass so a failed upload never triggers a delete of its counterpart.
-  * @default false
-  */
-  prune?: boolean;
-  /**
-  * When `true`, the first failing operation rejects {@link sync} instead of being collected in
-  * `errors`. Pruning is skipped when a copy-phase error stops the run.
-  * @default false
-  */
-  stopOnError?: boolean;
-  /** Transform each source key into the destination key. Defaults to identity. */
-  transformKey?: (key: string) => string;
-}
-interface SyncResult {
-  /** Destination keys removed because they were absent from the source (only when `prune`). */
-  deleted: string[];
-  errors?: BulkError[];
-  /** Source keys whose destination copy already matched and was left untouched. */
-  unchanged: string[];
-  /** Source keys re-uploaded because the destination copy differed. */
-  updated: string[];
-  /** Source keys newly created at the destination. */
-  uploaded: string[];
-}
-/**
-* Provider-agnostic facade over a {@link BaseStorage} instance.
-*
-* Provides a small, consistent surface (`upload`, `download`, `head`, `exists`, `delete`, `copy`,
-* `move`, `list`, `listAll`, `url`, `signedUploadUrl`) and a `raw` escape hatch to the adapter's native
-* client. A separate {@link transfer} top-level export streams every object from one Files instance
-* to another for cross-provider migration.
-*
-* Each operation accepts per-call `signal`, `timeout`, and `retries` via {@link OperationOptions};
-* defaults set on the constructor are merged in (per-call wins). Single-key methods also accept an
-* array of keys (or {@link BulkUploadItem}s for `upload`) to run a bounded-concurrency batch and
-* return a structured `{ ..., errors? }` result instead of throwing on partial failure.
-*
-* When constructed with a `prefix`, every key is resolved relative to the prefix and the prefix is
-* stripped back off the keys returned in results — application code works in its own namespace.
-*
-* Pass `hooks: { onAction, onError, onRetry }` to observe activity. Hooks are fire-and-forget and
-* never fail the operation they observe.
-* @example
-* ```ts
-* import { Files, S3Storage } from "@visulima/storage";
-*
-* const files = new Files({
-*   adapter: new S3Storage({ bucket: "uploads", region: "us-east-1" }),
-*   prefix: "users",
-*   defaults: { timeout: 30_000 },
-*   hooks: { onAction: (event) => console.log(event.type, event.key) },
-* });
-*
-* await files.upload("123/avatar.png", buffer, { contentType: "image/png" });
-* const head = await files.head("123/avatar.png");
-* for await (const file of files.listAll({ prefix: "123/" })) {
-*   console.log(file.key, file.size);
-* }
-* ```
-*/
-declare class Files<TStorage extends BaseStorage = BaseStorage> {
-  readonly adapter: TStorage;
-  private readonly defaults;
-  private readonly hooks;
-  private readonly prefix;
-  private readonly readonlyMode;
-  constructor(options: FilesOptions<TStorage>);
-  /**
-  * Adapter capability + mode snapshot. Read before relying on an optional operation
-  * (`range` downloads, custom `metadata`, `cacheControl`) so callers can branch instead of
-  * hitting a `MethodNotAllowed` mid-flight. `readonly` reflects this view, not the adapter.
-  */
-  get capabilities(): StorageCapabilities;
-  /**
-  * Derive a read-only view sharing this instance's adapter, prefix, defaults, and hooks. Every
-  * mutating call on the returned client fails with `FilesError { code: "ReadOnly" }` before the
-  * adapter is touched. Cheaper and safer than handing a writable client to code that should only
-  * read.
-  * @example
-  * ```ts
-  * const ro = files.readonly();
-  * await ro.download("a.txt"); // ok
-  * await ro.delete("a.txt");   // throws ReadOnly
-  * ```
-  */
-  readonly(): Files<TStorage>;
-  /** Fail closed before any adapter mutation when this view is read-only. */
-  private assertWritable;
-  /**
-  * Escape hatch to the adapter's native client (S3Client, BlobServiceClient, ...).
-  * Typed via the `TStorage` parameter, so pinning the adapter type at construction yields a
-  * typed view of the native client. Returns `undefined` when the adapter has no native client
-  * (e.g. DiskStorage).
-  */
-  get raw(): TStorage["raw"];
-  /** Resolve a caller-supplied key into the underlying storage key. */
-  private resolveKey;
-  /**
-  * Strip the constructor prefix off a key returned by the adapter. Returns `null` when the key
-  * is outside the prefix or is the bare prefix itself (used to filter `list()` results on a path
-  * boundary and drop any synthetic directory entry the adapter may emit).
-  */
-  private stripPrefix;
-  /**
-  * Merge constructor defaults with per-call options. When `hooks.onRetry` is configured,
-  * fold a wrapped `onRetry` into the per-call retry config so the hook fires with
-  * facade-level context (type, key, from/to) for each retry attempt the adapter performs.
-  */
-  private mergeOptions;
-  private emitAction;
-  private emitError;
-  private withHooks;
-  /**
-  * Upload a single object, or — when passed an array of {@link BulkUploadItem}s — bulk-upload
-  * many in one call with bounded concurrency.
-  */
-  upload(key: string, body: FileBody, options?: OperationOptions & UploadOptions): Promise<FileObject>;
-  upload(items: BulkUploadItem[], options?: BulkUploadOptions): Promise<BulkUploadResult>;
-  private uploadOne;
-  private uploadMany;
-  /**
-  * Download a single object, or — when passed an array of keys — bulk-download many in one
-  * call with bounded concurrency.
-  */
-  download(key: string, options?: DownloadOptions): Promise<DownloadResult>;
-  download(keys: string[], options?: BulkDownloadOptions): Promise<BulkDownloadResult>;
-  private assertRangeSupported;
-  private downloadOne;
-  private downloadMany;
-  /**
-  * Download a single object as a readable stream instead of a buffered {@link DownloadResult}.
-  * Backed by the adapter's native `getStream()`, this never allocates the whole payload in memory,
-  * making it the right choice for serving large objects without the `.raw` escape hatch. Object
-  * metadata (size, content-type, etag, last-modified) is fetched alongside the stream.
-  */
-  downloadStream(key: string, options?: OperationOptions): Promise<DownloadStreamResult>;
-  /**
-  * Fetch metadata for a single object, or — when passed an array of keys — bulk-head many in
-  * one call with bounded concurrency.
-  */
-  head(key: string, options?: OperationOptions): Promise<FileObject>;
-  head(keys: string[], options?: BulkOptions): Promise<BulkHeadResult>;
-  private headOne;
-  private headMany;
-  /**
-  * Resolves to `true`/`false` for a single key, or — when passed an array — splits the keys
-  * into `existing` and `missing` arrays. Hard errors (auth, transport) are reported in
-  * `errors`. Never throws for a missing object.
-  */
-  exists(key: string, options?: OperationOptions): Promise<boolean>;
-  exists(keys: string[], options?: BulkOptions): Promise<BulkExistsResult>;
-  private existsOne;
-  private existsMany;
-  /**
-  * Delete a single object (resolves to `void`, throws on failure), or — when passed an array
-  * of keys — delete many in one call. Adapters with a native bulk-delete primitive (S3's
-  * `DeleteObjects`, Supabase's `remove`, UploadThing's `deleteFiles`) use it via
-  * {@link BaseStorage.deleteBatch}; otherwise the keys are fanned out with bounded concurrency.
-  */
-  delete(key: string, options?: OperationOptions): Promise<void>;
-  delete(keys: string[], options?: BulkOptions): Promise<BulkDeleteResult>;
-  private deleteOne;
-  private deleteMany;
-  /**
-  * Copy `source` to `destination` (both resolved under any constructor prefix). Returns the
-  * destination object's metadata with the caller-facing (un-prefixed) key.
-  */
-  copy(source: string, destination: string, options?: OperationOptions & {
-    storageClass?: string;
-  }): Promise<FileObject>;
-  /**
-  * Rename `source` to `destination`. Uses the adapter's native rename where one exists
-  * (DiskStorage atomic move, Cloudinary server-side rename) and falls back to
-  * `copy` + `delete` otherwise. Moving a key onto itself is a no-op. Also accepts an array of
-  * `{ from, to }` items for bounded-concurrency bulk moves; per-item failures land in `errors`.
-  */
-  move(from: string, to: string, options?: OperationOptions & {
-    storageClass?: string;
-  }): Promise<FileObject>;
-  move(items: BulkMoveItem[], options?: BulkOptions): Promise<BulkMoveResult>;
-  private moveOne;
-  private moveMany;
-  /**
-  * List objects in the bucket. Returned keys have any constructor prefix stripped off, and
-  * keys outside the prefix namespace (e.g. `users-archive/` when prefix is `users`) are filtered
-  * out. The optional `prefix` filter is interpreted *relative to the constructor prefix*.
-  *
-  * Pass `delimiter` for directory-style listing: keys are collapsed into S3-style common
-  * prefixes and the call returns `{ files, prefixes }` instead of a flat array (see
-  * {@link ListDirectoryResult}). Objects with no further delimiter after the listing prefix come
-  * back as `files`; everything below a shared boundary folds into a single `prefixes` entry.
-  *
-  * **Caveat with constructor prefix**: `limit` is applied by the underlying adapter *before*
-  * the path-boundary filter runs, so the returned array may contain fewer than `limit` items
-  * even when more in-namespace objects exist. Use {@link Files.listAll} when you need every
-  * in-namespace object.
-  */
-  list(options?: Omit<ListOptions, "delimiter"> & OperationOptions): Promise<FileObject[]>;
-  list(options: ListOptions & OperationOptions & {
-    delimiter: string;
-  }): Promise<ListDirectoryResult>;
-  /**
-  * Native directory listing: push the `delimiter` down to an adapter that collapses common
-  * prefixes server-side ({@link BaseStorage.supportsDelimiter}). Resolves the listing prefix
-  * against the constructor prefix, then strips it back off the returned keys and prefixes so the
-  * result matches the facade-synthesized shape.
-  */
-  private listDirectoryNative;
-  /**
-  * Walk every object in the bucket. Yields one {@link FileObject} at a time as an async
-  * iterable; pages internally so callers don't have to thread a cursor. Returned keys have any
-  * constructor prefix stripped off and out-of-namespace keys are filtered out, just like
-  * {@link Files.list}.
-  *
-  * Most adapters return all objects in a single `list()` call (the default `limit` is 1000),
-  * so this is effectively `list` + iteration for them. Adapters that paginate natively can
-  * override `list` to honour the per-page `limit` and `listAll` will keep pulling pages until
-  * the page is short.
-  * @example
-  * ```ts
-  * for await (const file of files.listAll({ prefix: "avatars/" })) {
-  *   console.log(file.key, file.size);
-  * }
-  * ```
-  */
-  listAll(options?: ListAllOptions & OperationOptions): AsyncGenerator<FileObject, void, void>;
-  url(key: string, options?: OperationOptions & SignedReadUrlOptions): Promise<string>;
-  signedUploadUrl(key: string, options?: OperationOptions & SignedUploadUrlOptions): Promise<string>;
-}
-export { SyncProgress as A, BulkDeleteResult as B, TransferProgress as C, DownloadOptions as D, UploadControlState as E, Files as F, UploadControlToken as G, HookActionType as H, UploadOptions as I, UploadProgress as J, UploadProgressCallback as K, ListAllOptions as L, MultipartOptions as M, SyncOptions as S, TransferOptions as T, UploadControl as U, SyncResult as a, TransferResult as b, BulkDownloadOptions as c, BulkDownloadResult as d, BulkError as e, BulkExistsResult as f, BulkHeadResult as g, BulkMoveItem as h, BulkMoveResult as i, BulkOptions as j, BulkUploadItem as k, BulkUploadOptions as l, BulkUploadResult as m, DownloadRange as n, DownloadResult as o, DownloadStreamResult as p, FileBody as q, FileObject as r, FilesHooks as s, FilesOptions as t, HookEvent as u, ListDirectoryResult as v, ListOptions as w, SignedReadUrlOptions as x, SignedUploadUrlOptions as y, StorageCapabilities as z };