@velajs/storage 0.3.1 → 0.3.2

package/dist/storage.error-DVCOkJhc.js

@@ -0,0 +1,49 @@
+//#region src/storage.error.ts
+/** Codes that are safe to retry by default (transient failures). */
+const RETRYABLE = /* @__PURE__ */ new Set([
+	"Network",
+	"RateLimited",
+	"Timeout",
+	"Provider"
+]);
+var StorageError = class StorageError extends Error {
+	name = "StorageError";
+	code;
+	retryable;
+	status;
+	/** Whether `message` is non-client-safe (provider/transport/wrapped origin). */
+	internal;
+	constructor(code, message, options) {
+		super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+		this.code = code;
+		this.status = options?.status;
+		this.retryable = options?.retryable ?? RETRYABLE.has(code);
+		this.internal = options?.internal ?? false;
+	}
+	/** Wrap an arbitrary thrown value as a `StorageError` (idempotent). */
+	static wrap(e) {
+		if (e instanceof StorageError) return e;
+		if (isAbort(e)) return new StorageError("Aborted", "operation aborted", { cause: e });
+		return new StorageError("Provider", e instanceof Error ? e.message : String(e), {
+			cause: e,
+			internal: true
+		});
+	}
+	/** Map a transport status code to a `StorageError` (5xx/429 retryable). */
+	static fromStatus(status, message, cause) {
+		return new StorageError(status === 404 ? "NotFound" : status === 403 || status === 401 ? "AccessDenied" : status === 409 ? "Conflict" : status === 429 ? "RateLimited" : status >= 500 ? "Provider" : "InvalidRequest", message, {
+			status,
+			cause,
+			retryable: status === 429 || status >= 500,
+			internal: true
+		});
+	}
+};
+/** True for `AbortError`-shaped values (DOMException or `{ name: 'AbortError' }`). */
+function isAbort(e) {
+	return typeof e === "object" && e !== null && "name" in e && e.name === "AbortError";
+}
+//#endregion
+export { isAbort as n, StorageError as t };
+
+//# sourceMappingURL=storage.error-DVCOkJhc.js.map

package/dist/storage.error-DVCOkJhc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.error-DVCOkJhc.js","names":[],"sources":["../src/storage.error.ts"],"sourcesContent":["/**\n * The single error taxonomy for `@velajs/storage`. Every driver maps its\n * provider/transport failures onto a {@link StorageErrorCode}; the facade's\n * capability gates throw `Unsupported`; the retry loop keys off\n * {@link StorageError.retryable}; and the HTTP controller maps codes to\n * status via its own `codeToHttp()` table.\n */\nexport type StorageErrorCode =\n  | 'NotFound'\n  | 'AccessDenied'\n  | 'Unsupported'\n  | 'ReadOnly'\n  | 'InvalidKey'\n  | 'InvalidRequest'\n  | 'Conflict'\n  | 'RateLimited'\n  | 'Network'\n  | 'Timeout'\n  | 'Aborted'\n  | 'Provider'\n  | 'Parse';\n\n/** Codes that are safe to retry by default (transient failures). */\nconst RETRYABLE: ReadonlySet<StorageErrorCode> = new Set<StorageErrorCode>([\n  'Network',\n  'RateLimited',\n  'Timeout',\n  'Provider',\n]);\n\nexport interface StorageErrorOptions {\n  cause?: unknown;\n  /** Underlying HTTP status, when the failure came from a transport response. */\n  status?: number;\n  /** Override the default retryability implied by {@link StorageErrorCode}. */\n  retryable?: boolean;\n  /**\n   * True when `message` came from a provider/transport/wrapped source rather\n   * than being authored as client-safe text. The HTTP controller redacts such\n   * messages so raw provider detail never reaches a client. Default false —\n   * a bare `new StorageError(code, msg)` is the author's vouch that `msg` is\n   * client-safe; driver/wrap code MUST set this when echoing provider text.\n   */\n  internal?: boolean;\n}\n\nexport class StorageError extends Error {\n  override name = 'StorageError';\n  readonly code: StorageErrorCode;\n  readonly retryable: boolean;\n  readonly status: number | undefined;\n  /** Whether `message` is non-client-safe (provider/transport/wrapped origin). */\n  readonly internal: boolean;\n\n  constructor(code: StorageErrorCode, message: string, options?: StorageErrorOptions) {\n    super(message, options?.cause !== undefined ? { cause: options.cause } : undefined);\n    this.code = code;\n    this.status = options?.status;\n    this.retryable = options?.retryable ?? RETRYABLE.has(code);\n    this.internal = options?.internal ?? false;\n  }\n\n  /** Wrap an arbitrary thrown value as a `StorageError` (idempotent). */\n  static wrap(e: unknown): StorageError {\n    if (e instanceof StorageError) return e;\n    if (isAbort(e)) return new StorageError('Aborted', 'operation aborted', { cause: e });\n    // The wrapped message is arbitrary provider/host text — never client-safe.\n    return new StorageError('Provider', e instanceof Error ? e.message : String(e), {\n      cause: e,\n      internal: true,\n    });\n  }\n\n  /** Map a transport status code to a `StorageError` (5xx/429 retryable). */\n  static fromStatus(status: number, message: string, cause?: unknown): StorageError {\n    const code: StorageErrorCode =\n      status === 404\n        ? 'NotFound'\n        : status === 403 || status === 401\n          ? 'AccessDenied'\n          : status === 409\n            ? 'Conflict'\n            : status === 429\n              ? 'RateLimited'\n              : status >= 500\n                ? 'Provider'\n                : 'InvalidRequest';\n    return new StorageError(code, message, {\n      status,\n      cause,\n      retryable: status === 429 || status >= 500,\n      // Message came off a transport response — treat as non-client-safe.\n      internal: true,\n    });\n  }\n}\n\n/** True for `AbortError`-shaped values (DOMException or `{ name: 'AbortError' }`). */\nexport function isAbort(e: unknown): boolean {\n  return (\n    typeof e === 'object' &&\n    e !== null &&\n    'name' in e &&\n    (e as { name?: unknown }).name === 'AbortError'\n  );\n}\n"],"mappings":";;AAuBA,MAAM,4BAA2C,IAAI,IAAsB;CACzE;CACA;CACA;CACA;AACF,CAAC;AAkBD,IAAa,eAAb,MAAa,qBAAqB,MAAM;CACtC,OAAgB;CAChB;CACA;CACA;;CAEA;CAEA,YAAY,MAAwB,SAAiB,SAA+B;EAClF,MAAM,SAAS,SAAS,UAAU,KAAA,IAAY,EAAE,OAAO,QAAQ,MAAM,IAAI,KAAA,CAAS;EAClF,KAAK,OAAO;EACZ,KAAK,SAAS,SAAS;EACvB,KAAK,YAAY,SAAS,aAAa,UAAU,IAAI,IAAI;EACzD,KAAK,WAAW,SAAS,YAAY;CACvC;;CAGA,OAAO,KAAK,GAA0B;EACpC,IAAI,aAAa,cAAc,OAAO;EACtC,IAAI,QAAQ,CAAC,GAAG,OAAO,IAAI,aAAa,WAAW,qBAAqB,EAAE,OAAO,EAAE,CAAC;EAEpF,OAAO,IAAI,aAAa,YAAY,aAAa,QAAQ,EAAE,UAAU,OAAO,CAAC,GAAG;GAC9E,OAAO;GACP,UAAU;EACZ,CAAC;CACH;;CAGA,OAAO,WAAW,QAAgB,SAAiB,OAA+B;EAahF,OAAO,IAAI,aAXT,WAAW,MACP,aACA,WAAW,OAAO,WAAW,MAC3B,iBACA,WAAW,MACT,aACA,WAAW,MACT,gBACA,UAAU,MACR,aACA,kBACgB,SAAS;GACrC;GACA;GACA,WAAW,WAAW,OAAO,UAAU;GAEvC,UAAU;EACZ,CAAC;CACH;AACF;;AAGA,SAAgB,QAAQ,GAAqB;CAC3C,OACE,OAAO,MAAM,YACb,MAAM,QACN,UAAU,KACT,EAAyB,SAAS;AAEvC"}

package/dist/storage.types-BJN7Yp1J.d.ts

@@ -0,0 +1,288 @@
+//#region src/storage.error.d.ts
+/**
+ * The single error taxonomy for `@velajs/storage`. Every driver maps its
+ * provider/transport failures onto a {@link StorageErrorCode}; the facade's
+ * capability gates throw `Unsupported`; the retry loop keys off
+ * {@link StorageError.retryable}; and the HTTP controller maps codes to
+ * status via its own `codeToHttp()` table.
+ */
+type StorageErrorCode = 'NotFound' | 'AccessDenied' | 'Unsupported' | 'ReadOnly' | 'InvalidKey' | 'InvalidRequest' | 'Conflict' | 'RateLimited' | 'Network' | 'Timeout' | 'Aborted' | 'Provider' | 'Parse';
+interface StorageErrorOptions {
+  cause?: unknown;
+  /** Underlying HTTP status, when the failure came from a transport response. */
+  status?: number;
+  /** Override the default retryability implied by {@link StorageErrorCode}. */
+  retryable?: boolean;
+  /**
+   * True when `message` came from a provider/transport/wrapped source rather
+   * than being authored as client-safe text. The HTTP controller redacts such
+   * messages so raw provider detail never reaches a client. Default false —
+   * a bare `new StorageError(code, msg)` is the author's vouch that `msg` is
+   * client-safe; driver/wrap code MUST set this when echoing provider text.
+   */
+  internal?: boolean;
+}
+declare class StorageError extends Error {
+  name: string;
+  readonly code: StorageErrorCode;
+  readonly retryable: boolean;
+  readonly status: number | undefined;
+  /** Whether `message` is non-client-safe (provider/transport/wrapped origin). */
+  readonly internal: boolean;
+  constructor(code: StorageErrorCode, message: string, options?: StorageErrorOptions);
+  /** Wrap an arbitrary thrown value as a `StorageError` (idempotent). */
+  static wrap(e: unknown): StorageError;
+  /** Map a transport status code to a `StorageError` (5xx/429 retryable). */
+  static fromStatus(status: number, message: string, cause?: unknown): StorageError;
+}
+/** True for `AbortError`-shaped values (DOMException or `{ name: 'AbortError' }`). */
+declare function isAbort(e: unknown): boolean;
+//#endregion
+//#region src/storage.types.d.ts
+type Body = Blob | File | ReadableStream<Uint8Array> | ArrayBuffer | ArrayBufferView | Uint8Array | string;
+/** A multipart part must have a known length, so streams are excluded. */
+type PartBody = Blob | ArrayBuffer | ArrayBufferView | Uint8Array;
+interface RetryBackoffContext {
+  /** 1-based retry number (attempt 1 is the first retry after the initial call). */
+  attempt: number;
+  error: StorageError;
+}
+type RetryOptions = number | {
+  max: number;
+  backoff?: (ctx: RetryBackoffContext) => number;
+};
+interface OperationOptions {
+  /** Abort the operation when this signal fires. */
+  signal?: AbortSignal;
+  /** Per-attempt timeout in ms. `0` or negative disables timeout handling. */
+  timeout?: number;
+  /** Retry transient failures. A number is treated as `{ max: number }`. */
+  retries?: RetryOptions;
+}
+interface UploadProgress {
+  /** Cumulative bytes sent so far. */
+  loaded: number;
+  /** Total bytes to send, when known (omitted for unknown-length streams). */
+  total?: number;
+}
+/** Tuning for multipart uploads. `multipart: true` uses these defaults. */
+interface MultipartOptions {
+  /** Bytes per part. Default 5 MiB (S3's minimum non-final part size). */
+  partSize?: number;
+  /** Parts uploaded concurrently. Default 4. */
+  concurrency?: number;
+}
+interface UploadOptions extends OperationOptions {
+  contentType?: string;
+  /** Persisted only when the driver advertises `supportsCacheControl`. */
+  cacheControl?: string;
+  /** Persisted only when the driver advertises `supportsMetadata` (empty == none). */
+  metadata?: Record<string, string>;
+  onProgress?: (p: UploadProgress) => void;
+  /** Force/relax multipart. `true` uses {@link MultipartOptions} defaults. */
+  multipart?: boolean | MultipartOptions;
+}
+interface UploadResult {
+  key: string;
+  size: number;
+  contentType: string;
+  etag?: string;
+  lastModified?: number;
+  /** Reserved for the versioning middleware / provider versioning. */
+  versionId?: string;
+}
+/** 0-based, `end` inclusive (matches the HTTP `Range` header). */
+interface ByteRange {
+  start: number;
+  end?: number;
+}
+interface DownloadOptions extends OperationOptions {
+  /** Honored only when the driver advertises `supportsRange`. */
+  range?: ByteRange;
+}
+interface StoredFile {
+  key: string;
+  name: string;
+  size: number;
+  type: string;
+  lastModified?: number;
+  etag?: string;
+  metadata?: Record<string, string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  blob(): Promise<Blob>;
+  /** Web Streams only. */
+  stream(): ReadableStream<Uint8Array>;
+}
+interface ListOptions extends OperationOptions {
+  prefix?: string;
+  cursor?: string;
+  limit?: number;
+  /** S3-style folder folding. Honored only when the driver advertises `supportsDelimiter`. */
+  delimiter?: string;
+}
+interface ListResult {
+  items: StoredFile[];
+  /** Common prefixes when `delimiter` is set. */
+  prefixes?: string[];
+  /** Continuation cursor; absent when the listing is exhausted. */
+  cursor?: string;
+}
+interface DeleteManyOptions extends OperationOptions {
+  /** Concurrency for the fan-out fallback. Default 8. */
+  concurrency?: number;
+  /** Stop at the first error instead of collecting all. Default false. */
+  stopOnError?: boolean;
+}
+interface DeleteManyError {
+  key: string;
+  error: StorageError;
+}
+interface DeleteManyResult {
+  deleted: string[];
+  errors?: DeleteManyError[];
+}
+interface UrlOptions extends OperationOptions {
+  expiresIn?: number;
+  /** Forces the signing path (e.g. to set `Content-Disposition: attachment`). */
+  responseContentDisposition?: string;
+}
+interface SignUploadOptions extends OperationOptions {
+  expiresIn: number;
+  contentType?: string;
+  /** When set, drivers use a POST policy so the store enforces the size cap. */
+  maxSize?: number;
+  minSize?: number;
+}
+type SignedUpload = {
+  method: 'PUT';
+  url: string;
+  headers?: Record<string, string>;
+} | {
+  method: 'POST';
+  url: string;
+  fields: Record<string, string>;
+};
+/** Advisory descriptor for what a driver's signing supports. */
+interface SignedUrlCapability {
+  /** Can mint a presigned download URL via `url()`. */
+  supported: boolean;
+  /** Can mint a presigned upload via `signedUploadUrl()`. */
+  upload: boolean;
+  /** Provider ceiling on `expiresIn` (seconds), if any. */
+  maxExpiresIn?: number;
+}
+interface CreateMultipartOptions extends OperationOptions {
+  contentType?: string;
+  cacheControl?: string;
+  metadata?: Record<string, string>;
+}
+interface UploadedPart {
+  partNumber: number;
+  etag: string;
+  size?: number;
+}
+interface MultipartUpload {
+  readonly key: string;
+  readonly uploadId: string;
+  uploadPart(partNumber: number, body: PartBody, opts?: OperationOptions): Promise<UploadedPart>;
+  complete(parts: UploadedPart[], opts?: OperationOptions): Promise<UploadResult>;
+  abort(opts?: OperationOptions): Promise<void>;
+  /** Enables cross-request resume where the provider can list uploaded parts. */
+  listParts?(opts?: OperationOptions): Promise<UploadedPart[]>;
+}
+interface SignedMultipartCreate {
+  uploadId: string;
+  partSize: number;
+}
+interface SignedPart {
+  url: string;
+  headers?: Record<string, string>;
+}
+interface SignedMultipartCapability {
+  create(key: string, opts: {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    partSize?: number;
+  }): Promise<SignedMultipartCreate>;
+  signPart(key: string, uploadId: string, partNumber: number, opts?: {
+    expiresIn?: number;
+  }): Promise<SignedPart>;
+  complete(key: string, uploadId: string, parts: UploadedPart[]): Promise<UploadResult>;
+  abort(key: string, uploadId: string): Promise<void>;
+}
+interface StorageDriver<Raw = unknown> {
+  readonly name: string;
+  readonly raw: Raw;
+  readonly reportsUploadProgress?: boolean;
+  readonly supportsRange?: boolean;
+  readonly supportsDelimiter?: boolean;
+  readonly supportsMetadata?: boolean;
+  readonly supportsCacheControl?: boolean;
+  readonly supportsServerSideCopy?: boolean;
+  readonly signedUrl?: SignedUrlCapability;
+  upload(key: string, body: Body, opts?: UploadOptions): Promise<UploadResult>;
+  download(key: string, opts?: DownloadOptions): Promise<StoredFile>;
+  head(key: string, opts?: OperationOptions): Promise<StoredFile>;
+  exists(key: string, opts?: OperationOptions): Promise<boolean>;
+  delete(key: string, opts?: OperationOptions): Promise<void>;
+  /** Optional native bulk delete; the facade fans out to `delete` otherwise. */
+  deleteMany?(keys: string[], opts?: DeleteManyOptions): Promise<DeleteManyResult>;
+  copy(from: string, to: string, opts?: OperationOptions): Promise<void>;
+  /** Optional native rename; the facade falls back to copy+delete otherwise. */
+  move?(from: string, to: string, opts?: OperationOptions): Promise<void>;
+  list(opts?: ListOptions): Promise<ListResult>;
+  url(key: string, opts?: UrlOptions): Promise<string>;
+  signedUploadUrl(key: string, opts: SignUploadOptions): Promise<SignedUpload>;
+  /** Server-side multipart. Presence == capability. */
+  createMultipartUpload?(key: string, opts?: CreateMultipartOptions): Promise<MultipartUpload>;
+  resumeMultipartUpload?(key: string, uploadId: string): MultipartUpload;
+  /** Browser-direct presigned multipart. Presence == capability. */
+  signedMultipart?: SignedMultipartCapability;
+}
+/** Queryable capability snapshot for callers that branch up-front. */
+interface StorageCapabilities {
+  rangeRead: boolean;
+  uploadProgress: boolean;
+  delimiter: boolean;
+  metadata: boolean;
+  cacheControl: boolean;
+  serverSideCopy: boolean;
+  multipart: boolean;
+  signedMultipart: boolean;
+  signedUrl: SignedUrlCapability;
+}
+interface StorageHookEvent {
+  type: string;
+  key?: string;
+  status: 'success' | 'error';
+  durationMs: number;
+  error?: StorageError;
+}
+interface StorageHooks {
+  onOperation?: (e: StorageHookEvent) => void;
+  onError?: (e: {
+    type: string;
+    key?: string;
+    error: StorageError;
+  }) => void;
+  onRetry?: (e: {
+    type: string;
+    key?: string;
+    attempt: number;
+    maxRetries: number;
+    delayMs: number;
+    error: StorageError;
+  }) => void;
+}
+interface StorageOptions extends OperationOptions {
+  driver: StorageDriver;
+  /** Sub-scopes the keyspace within a bucket; normalized (no leading/trailing '/'). */
+  prefix?: string;
+  /** Reject all mutating operations. */
+  readonly?: boolean;
+  hooks?: StorageHooks;
+}
+//#endregion
+export { UploadResult as A, StorageDriver as C, StoredFile as D, StorageOptions as E, StorageErrorOptions as F, isAbort as I, UrlOptions as M, StorageError as N, UploadOptions as O, StorageErrorCode as P, StorageCapabilities as S, StorageHooks as T, SignedMultipartCapability as _, DeleteManyOptions as a, SignedUpload as b, ListOptions as c, MultipartUpload as d, OperationOptions as f, SignUploadOptions as g, RetryOptions as h, DeleteManyError as i, UploadedPart as j, UploadProgress as k, ListResult as l, RetryBackoffContext as m, ByteRange as n, DeleteManyResult as o, PartBody as p, CreateMultipartOptions as r, DownloadOptions as s, Body as t, MultipartOptions as u, SignedMultipartCreate as v, StorageHookEvent as w, SignedUrlCapability as x, SignedPart as y };
+//# sourceMappingURL=storage.types-BJN7Yp1J.d.ts.map

package/dist/storagesdk/index.d.ts

@@ -1,78 +1,79 @@
-import type { Body, StorageDriver } from '../storage.types';
+import { C as StorageDriver, t as Body } from "../storage.types-BJN7Yp1J.js";
+//#region src/storagesdk/index.d.ts
 /** Metadata for one storagesdk object (path-based). */
-export interface StorageSdkItemMeta {
-    path: string;
-    size: number;
-    contentType: string;
-    etag: string;
-    lastModified: Date | number;
-    metadata?: Record<string, string>;
+interface StorageSdkItemMeta {
+  path: string;
+  size: number;
+  contentType: string;
+  etag: string;
+  lastModified: Date | number;
+  metadata?: Record<string, string>;
 }
 /** A storagesdk download result: metadata plus the buffered body. */
-export interface StorageSdkItem extends StorageSdkItemMeta {
-    body: Uint8Array<ArrayBuffer>;
+interface StorageSdkItem extends StorageSdkItemMeta {
+  body: Uint8Array<ArrayBuffer>;
 }
-export interface StorageSdkListResult {
-    items: StorageSdkItemMeta[];
-    cursor?: string;
-    prefixes?: string[];
+interface StorageSdkListResult {
+  items: StorageSdkItemMeta[];
+  cursor?: string;
+  prefixes?: string[];
 }
 /** The structural subset of a `@storagesdk/adapters` adapter we consume. */
-export interface StorageSdkAdapterLike<Raw = unknown> {
-    readonly name?: string;
-    readonly raw?: Raw;
-    download(path: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<StorageSdkItem>;
-    head(path: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<StorageSdkItemMeta>;
-    list(opts?: {
-        prefix?: string;
-        cursor?: string;
-        limit?: number;
-        delimiter?: string;
-        signal?: AbortSignal;
-    }): Promise<StorageSdkListResult>;
-    url(path: string, opts?: {
-        expiresIn?: number;
-        signal?: AbortSignal;
-    }): Promise<string>;
-    upload(path: string, body: Body, opts?: {
-        contentType?: string;
-        metadata?: Record<string, string>;
-        signal?: AbortSignal;
-    }): Promise<StorageSdkItemMeta | void>;
-    delete(path: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    copy(from: string, to: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    move?(from: string, to: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    exists?(path: string, opts?: {
-        signal?: AbortSignal;
-    }): Promise<boolean>;
-    signedUploadUrl?(path: string, opts: {
-        expiresIn: number;
-        contentType?: string;
-    }): Promise<{
-        method: 'PUT';
-        url: string;
-        headers?: Record<string, string>;
-    }>;
+interface StorageSdkAdapterLike<Raw = unknown> {
+  readonly name?: string;
+  readonly raw?: Raw;
+  download(path: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<StorageSdkItem>;
+  head(path: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<StorageSdkItemMeta>;
+  list(opts?: {
+    prefix?: string;
+    cursor?: string;
+    limit?: number;
+    delimiter?: string;
+    signal?: AbortSignal;
+  }): Promise<StorageSdkListResult>;
+  url(path: string, opts?: {
+    expiresIn?: number;
+    signal?: AbortSignal;
+  }): Promise<string>;
+  upload(path: string, body: Body, opts?: {
+    contentType?: string;
+    metadata?: Record<string, string>;
+    signal?: AbortSignal;
+  }): Promise<StorageSdkItemMeta | void>;
+  delete(path: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  copy(from: string, to: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  move?(from: string, to: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<void>;
+  exists?(path: string, opts?: {
+    signal?: AbortSignal;
+  }): Promise<boolean>;
+  signedUploadUrl?(path: string, opts: {
+    expiresIn: number;
+    contentType?: string;
+  }): Promise<{
+    method: 'PUT';
+    url: string;
+    headers?: Record<string, string>;
+  }>;
 }
-export interface StorageSdkBridgeOptions {
-    /** Advertise range support (only if your adapter honors `range`). Default false. */
-    supportsRange?: boolean;
-    /** Advertise delimiter/prefix support. Default false. */
-    supportsDelimiter?: boolean;
-    /** Advertise arbitrary metadata support. Default true. */
-    supportsMetadata?: boolean;
-    /** Advertise cache-control support. Default false. */
-    supportsCacheControl?: boolean;
+interface StorageSdkBridgeOptions {
+  /** Advertise range support (only if your adapter honors `range`). Default false. */
+  supportsRange?: boolean;
+  /** Advertise delimiter/prefix support. Default false. */
+  supportsDelimiter?: boolean;
+  /** Advertise arbitrary metadata support. Default true. */
+  supportsMetadata?: boolean;
+  /** Advertise cache-control support. Default false. */
+  supportsCacheControl?: boolean;
 }
 /**
  * Adapt a `@storagesdk/adapters` adapter to a {@link StorageDriver}.
@@ -82,4 +83,7 @@ export interface StorageSdkBridgeOptions {
  * so this is an explicit mapping. Multipart / presigned-multipart are not
  * exposed (the facade will gate them as `Unsupported`).
  */
-export declare function storageSdkDriver<Raw = unknown>(adapter: StorageSdkAdapterLike<Raw>, options?: StorageSdkBridgeOptions): StorageDriver<Raw>;
+declare function storageSdkDriver<Raw = unknown>(adapter: StorageSdkAdapterLike<Raw>, options?: StorageSdkBridgeOptions): StorageDriver<Raw>;
+//#endregion
+export { StorageSdkAdapterLike, StorageSdkBridgeOptions, StorageSdkItem, StorageSdkItemMeta, StorageSdkListResult, storageSdkDriver };
+//# sourceMappingURL=index.d.ts.map