disk 0.8.18 → 0.8.20

package/dist/disk-BLF7FFqG.d.mts

@@ -0,0 +1,641 @@
+import { Client } from "openapi-fetch";
+import { components, paths } from "@archildata/api-types";
+
+//#region src/client.d.ts
+type ApiClient = Client<paths>;
+//#endregion
+//#region src/filesystem.d.ts
+/**
+ * A key-addressable filesystem over one or more Archil disks — the existing
+ * object API a {@link Disk} already exposes ({@link Disk.getObject},
+ * `putObject`, `deleteObject`, `listObjects`, `grep`, `exec`), captured as a
+ * contract so a multi-disk {@link Workspace} can be used anywhere a single disk
+ * is.
+ *
+ * A single {@link Disk} is the one-disk case: keys are relative to the disk
+ * root. A {@link Workspace} spans several disks, each mounted under a name, so
+ * its keys carry that name as the first segment (e.g. `data/reports/q1.csv`)
+ * and `listObjects`/`grep` fan out across every disk when the key/prefix
+ * doesn't name one.
+ *
+ * Both `Disk` and `Workspace` implement this interface, which is what keeps the
+ * two from drifting — adding a method here is a compile error until both do.
+ */
+interface FileSystem {
+  /** Read an object's full contents. Throws `ArchilS3Error` (404) if absent. */
+  getObject(key: string): Promise<Uint8Array>;
+  /** Create or overwrite an object. */
+  putObject(key: string, body: string | Uint8Array | ArrayBuffer, contentType?: string): Promise<PutObjectResult>;
+  /** Delete an object (idempotent). */
+  deleteObject(key: string): Promise<void>;
+  /** List objects and common (directory) prefixes under a key prefix. */
+  listObjects(prefix?: string, opts?: ListObjectsOptions): Promise<ListObjectsResult>;
+  /** Constant-time parallel grep. */
+  grep(opts: GrepOptions): Promise<GrepResult>;
+  /** Run a command in a sandbox with the filesystem mounted. */
+  exec(command: string): Promise<ExecResult>;
+}
+//#endregion
+//#region src/types.d.ts
+type DiskResponse = components["schemas"]["DiskResponse"];
+type MountResponse = components["schemas"]["MountResponse"];
+type MountConfigResponse = components["schemas"]["MountConfigResponse"];
+type DiskMetrics = components["schemas"]["DiskMetrics"];
+type ConnectedClient = components["schemas"]["ConnectedClient"];
+type AuthorizedUser = components["schemas"]["AuthorizedUser"];
+type CreateDiskRequest = components["schemas"]["CreateDiskRequest"];
+type MountConfig = components["schemas"]["MountConfig"];
+type S3Mount = components["schemas"]["S3Mount"];
+type GCSMount = components["schemas"]["GCSMount"];
+type R2Mount = components["schemas"]["R2Mount"];
+type S3CompatibleMount = components["schemas"]["S3CompatibleMount"];
+type AzureBlobMount = components["schemas"]["AzureBlobMount"];
+type DiskUser = components["schemas"]["DiskUser"];
+type TokenUser = components["schemas"]["TokenUser"];
+type AwsStsUser = components["schemas"]["AwsStsUser"];
+type CreateApiTokenRequest = components["schemas"]["CreateApiTokenRequest"];
+type ApiTokenResponse = components["schemas"]["ApiTokenResponse"];
+type ExecDiskResult = components["schemas"]["ExecDiskResult"];
+type ExecRequest = components["schemas"]["ExecRequest"];
+type GrepDiskResult = components["schemas"]["GrepDiskResult"];
+type GrepMatch = components["schemas"]["GrepMatch"];
+type GrepStoppedReason = components["schemas"]["GrepStoppedReason"];
+type DiskStatus = DiskResponse["status"];
+//#endregion
+//#region src/disk.d.ts
+interface MountOptions {
+  authToken?: string;
+  logLevel?: string;
+  serverAddress?: string;
+  insecure?: boolean;
+}
+type ExecResult = ExecDiskResult;
+type GrepResult = GrepDiskResult;
+interface GrepOptions {
+  /**
+   * Directory on the disk to search, relative to the disk root. An empty
+   * string or "/" means the disk root.
+   */
+  directory: string;
+  /** Extended regular expression (passed to `grep -E`). */
+  pattern: string;
+  /** Walk subdirectories breadth-first. Defaults to false. */
+  recursive?: boolean;
+  /** Wall-clock deadline for the entire request. Defaults to 30s. */
+  maxDurationSeconds?: number;
+  /**
+   * Maximum number of parallel grep workers. Higher values finish larger
+   * datasets within the deadline but consume more runtime capacity. The
+   * controlplane clamps this to the fleet's currently-available capacity.
+   * Defaults to 50.
+   */
+  concurrency?: number;
+  /**
+   * Stop scanning once the aggregator has this many matches. Returned
+   * matches are a sample of whichever workers reported first, not the
+   * lexicographically first N. Defaults to 1000.
+   */
+  maxResults?: number;
+}
+interface ShareUrlOptions {
+  /**
+   * Lifetime of the URL in seconds — any positive integer, up to 604800
+   * (7 days). Defaults to 86400 (24 hours).
+   */
+  expiresIn?: number;
+}
+interface ShareUrlResult {
+  /** Public, signed, time-limited URL that downloads the file. */
+  url: string;
+  /** Lifetime of the URL in seconds. */
+  expiresIn: number;
+}
+interface ListObjectsOptions {
+  /**
+   * List the entire subtree under the prefix. When false (the default), only
+   * the immediate level is returned — direct objects in `objects` and
+   * subdirectory prefixes in `commonPrefixes`, like listing a single directory.
+   * When true, every key under the prefix is returned flat (and
+   * `commonPrefixes` is empty).
+   */
+  recursive?: boolean;
+  /**
+   * Return only the first page instead of auto-paginating. By default
+   * listObjects follows continuation tokens until the listing is exhausted and
+   * returns every matching key. With `singlePage: true` it makes one request
+   * and the result carries `isTruncated` / `nextContinuationToken` so you can
+   * page manually (pass the token back via `continuationToken`).
+   */
+  singlePage?: boolean;
+  /**
+   * Stop after this many objects total (only meaningful when auto-paginating).
+   * The result's `isTruncated` is true if the cap cut the listing short.
+   */
+  limit?: number;
+  /** Start listing from this continuation token (from a prior `nextContinuationToken`). */
+  continuationToken?: string;
+  /** Return keys lexicographically after this one. */
+  startAfter?: string;
+}
+interface S3Object {
+  /** Object key (path on the disk). */
+  key: string;
+  /** Size in bytes. */
+  size: number;
+  /** Entity tag (quoted MD5 for single-part objects). */
+  etag?: string;
+  /** Last-modified time, if reported by the server. */
+  lastModified?: Date;
+}
+interface PutObjectResult {
+  /** Entity tag the server assigned (quoted, per S3 — e.g. `"\"abc123\""`). */
+  etag?: string;
+}
+interface ObjectMetadata {
+  /** Size in bytes. */
+  size: number;
+  /** Entity tag (quoted MD5 for single-part objects). */
+  etag?: string;
+  /** MIME type the object was stored with, if any. */
+  contentType?: string;
+  /** Last-modified time, if reported by the server. */
+  lastModified?: Date;
+}
+interface ListObjectsResult {
+  /** Objects in this page. */
+  objects: S3Object[];
+  /** Directory-like prefixes rolled up by `delimiter` (empty if no delimiter). */
+  commonPrefixes: string[];
+  /** True if more keys exist beyond this page. */
+  isTruncated: boolean;
+  /** Token to pass as `continuationToken` to fetch the next page. */
+  nextContinuationToken?: string;
+  /** Number of keys returned in this page. */
+  keyCount: number;
+  /** The prefix the listing was filtered by, echoed back by the server. */
+  prefix?: string;
+}
+/** A part to list in {@link Disk.completeMultipartUpload}. */
+interface UploadPart {
+  /** 1-based part number (1..=10000), strictly increasing across the list. */
+  partNumber: number;
+  /** Entity tag returned by {@link Disk.uploadPart} for this part. */
+  etag: string;
+}
+/** Handle to an in-progress multipart upload, returned by {@link Disk.createMultipartUpload}. */
+interface MultipartUpload {
+  /** Server-assigned upload id; pass to uploadPart/complete/abort/listParts. */
+  uploadId: string;
+  /** The object key this upload targets. */
+  key: string;
+  /** The bucket (disk id) the upload lives in. */
+  bucket: string;
+}
+/** The assembled object, returned by {@link Disk.completeMultipartUpload}. */
+interface CompletedMultipartUpload {
+  /** Multipart entity tag — S3's `md5(concat(partMd5s))-N` form. */
+  etag?: string;
+  /** Resource path of the completed object. */
+  location?: string;
+  /** The bucket (disk id). */
+  bucket?: string;
+  /** The object key. */
+  key?: string;
+}
+/** One part in a {@link Disk.listParts} listing. */
+interface PartInfo {
+  /** 1-based part number. */
+  partNumber: number;
+  /** Entity tag the server assigned to this part. */
+  etag?: string;
+  /** Size in bytes. */
+  size: number;
+  /** Time the part was uploaded, if reported. */
+  lastModified?: Date;
+}
+interface ListPartsOptions {
+  /** Cap parts returned in one page (server clamps to 1000). */
+  maxParts?: number;
+  /** Return parts after this part number (for pagination). */
+  partNumberMarker?: number;
+}
+interface PartListing {
+  /** The bucket (disk id), echoed by the server. */
+  bucket?: string;
+  /** The object key, echoed by the server. */
+  key?: string;
+  /** The upload id, echoed by the server. */
+  uploadId?: string;
+  /** Parts in this page, ascending by part number. */
+  parts: PartInfo[];
+  /** True if more parts exist beyond this page. */
+  isTruncated: boolean;
+  /** The part-number marker this page started after. */
+  partNumberMarker: number;
+  /** Pass back as `partNumberMarker` to fetch the next page. */
+  nextPartNumberMarker?: number;
+  /** Max parts the server was asked to return. */
+  maxParts: number;
+}
+/** One in-progress upload in a {@link Disk.listMultipartUploads} listing. */
+interface MultipartUploadSummary {
+  /** The object key the upload targets. */
+  key: string;
+  /** The upload id. */
+  uploadId: string;
+  /** When the upload was initiated, if reported. */
+  initiated?: Date;
+}
+interface ListMultipartUploadsOptions {
+  /** Only list uploads whose key begins with this prefix. */
+  prefix?: string;
+  /** Roll keys up to this delimiter into `commonPrefixes` (S3 supports "/"). */
+  delimiter?: string;
+  /** Resume listing keys after this one (with `uploadIdMarker`). */
+  keyMarker?: string;
+  /** Resume listing uploads after this upload id (requires `keyMarker`). */
+  uploadIdMarker?: string;
+  /** Cap uploads returned in one page (server clamps to 1000). */
+  maxUploads?: number;
+}
+interface MultipartUploadListing {
+  /** The bucket (disk id), echoed by the server. */
+  bucket?: string;
+  /** In-progress uploads in this page. */
+  uploads: MultipartUploadSummary[];
+  /** Key prefixes rolled up by `delimiter` (empty if no delimiter). */
+  commonPrefixes: string[];
+  /** True if more uploads exist beyond this page. */
+  isTruncated: boolean;
+  /** The key marker this page started after, echoed back. */
+  keyMarker?: string;
+  /** The upload-id marker this page started after, echoed back. */
+  uploadIdMarker?: string;
+  /** Pass back as `keyMarker` (with `nextUploadIdMarker`) for the next page. */
+  nextKeyMarker?: string;
+  /** Pass back as `uploadIdMarker` (with `nextKeyMarker`) for the next page. */
+  nextUploadIdMarker?: string;
+  /** The prefix the listing was filtered by, echoed back. */
+  prefix?: string;
+  /** The delimiter used, echoed back. */
+  delimiter?: string;
+  /** Max uploads the server was asked to return. */
+  maxUploads?: number;
+}
+interface DeleteObjectsOptions {
+  /**
+   * Quiet mode: the server omits the per-key success list and returns only
+   * failures, so the result's `deleted` array is empty. Cuts response size on
+   * large batches. Defaults to false.
+   */
+  quiet?: boolean;
+}
+/** A single per-key failure within a {@link Disk.deleteObjects} batch. */
+interface DeleteObjectsError {
+  /** The key that failed to delete. */
+  key: string;
+  /** S3 error code (e.g. "AccessDenied", "OperationAborted"), if provided. */
+  code?: string;
+  /** Human-readable failure detail, if provided. */
+  message?: string;
+}
+interface DeleteObjectsResult {
+  /** Keys the server confirmed deleted (empty in quiet mode). */
+  deleted: string[];
+  /** Per-key failures; empty when every key was deleted. */
+  errors: DeleteObjectsError[];
+}
+interface PutObjectOptions {
+  /** MIME type to store the object with. Default "application/octet-stream". */
+  contentType?: string;
+  /**
+   * Bodies larger than this take the multipart path; bodies at or below it take
+   * a single PutObject. Defaults to `partSize` (16 MiB), so by default the
+   * switch happens at the part size. Set it lower (e.g. 5 MiB) to start using
+   * multipart sooner, or to `Infinity` to force a single PutObject.
+   */
+  multipartThreshold?: number;
+  /**
+   * Bytes per part on the multipart path. Clamped to a minimum of 5 MiB (the S3
+   * floor for every part but the last). Default 16 MiB.
+   */
+  partSize?: number;
+  /** Max parts uploaded in parallel on the multipart path. Default 4. */
+  concurrency?: number;
+}
+/**
+ * The S3 transport function {@link DiskMultipart} uses, supplied by the owning
+ * {@link Disk} so the namespace shares the disk's credential and endpoint.
+ * @internal
+ */
+type S3RequestFn = (method: "GET" | "PUT" | "DELETE" | "HEAD" | "POST", key: string, opts?: {
+  body?: string | Uint8Array | ArrayBuffer;
+  contentType?: string;
+  query?: Record<string, string | number>;
+  retry?: boolean;
+}) => Promise<{
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  body: Uint8Array;
+}>;
+declare class Disk implements FileSystem {
+  readonly id: string;
+  readonly name: string;
+  readonly organization: string;
+  readonly status: DiskStatus;
+  readonly provider: string;
+  readonly region: string;
+  readonly createdAt: string;
+  readonly fsHandlerStatus?: string;
+  readonly lastAccessed?: string;
+  readonly dataSize?: number;
+  readonly monthlyUsage?: string;
+  readonly mounts?: MountResponse[];
+  readonly metrics?: DiskMetrics;
+  readonly connectedClients?: ConnectedClient[];
+  readonly authorizedUsers?: AuthorizedUser[];
+  readonly allowedIps?: string[];
+  /** @internal */
+  private readonly _client;
+  /** @internal */
+  private readonly _archilRegion;
+  /** Base URL for the S3-compatible API (port 9000 ingress). Empty if unset. */
+  private readonly _s3BaseUrl;
+  /** Lazily-constructed multipart namespace (see {@link multipart}). @internal */
+  private _multipart?;
+  /** @internal */
+  constructor(data: DiskResponse, client: ApiClient, archilRegion: string, s3BaseUrl?: string);
+  toJSON(): DiskResponse;
+  addUser(user: DiskUser): Promise<AuthorizedUser>;
+  removeUser(userType: "token" | "awssts", identifier: string): Promise<void>;
+  createToken(nickname: string): Promise<AuthorizedUser & {
+    token: string;
+    identifier: string;
+  }>;
+  removeTokenUser(identifier: string): Promise<void>;
+  getAllowedIPs(): Promise<string[]>;
+  setAllowedIPs(allowedIps: string[]): Promise<string[]>;
+  addAllowedIP(ip: string): Promise<string[]>;
+  removeAllowedIP(ip: string): Promise<string[]>;
+  delete(): Promise<void>;
+  /**
+   * Execute a command in a container with this disk mounted.
+   * Blocks until the command completes and returns stdout, stderr, and exit code.
+   */
+  exec(command: string): Promise<ExecResult>;
+  /**
+   * Constant-time parallel grep across files on this disk. Listing and
+   * matching are fanned out across ephemeral exec containers; the request
+   * finishes within the supplied time budget regardless of dataset size.
+   *
+   * The returned `stoppedReason` says whether the search ran to completion
+   * or short-circuited on `maxResults` / `maxDurationSeconds`. When
+   * stopping early, the matches returned are a sample (whichever workers
+   * reported first), not the lexicographically first N.
+   */
+  grep(opts: GrepOptions): Promise<GrepResult>;
+  /**
+   * Create a signed, time-limited URL that lets anyone download a single file
+   * from this disk without authentication. The returned URL embeds a
+   * cryptographically signed token carrying the disk, the file's key, and an
+   * expiry — share it directly; no API key is needed to redeem it.
+   *
+   * @param key   Path to the file on the disk (e.g. "reports/2026-01/data.pdf").
+   * @param opts  `expiresIn` sets the URL lifetime in seconds (any positive
+   *              integer, max 604800 = 7 days). Defaults to 24h.
+   */
+  share(key: string, opts?: ShareUrlOptions): Promise<ShareUrlResult>;
+  /**
+   * Read an object from the disk via the S3-compatible GetObject API and return
+   * its full contents as bytes. Throws `ArchilS3Error` if the object does not
+   * exist (status 404, code "NoSuchKey") or the request is rejected; use
+   * `headObject`/`objectExists` to check existence without throwing.
+   *
+   * @param key  Path on the disk (e.g. "reports/2026-01/data.json")
+   */
+  getObject(key: string): Promise<Uint8Array>;
+  /**
+   * Fetch an object's metadata (size, etag, content type, last-modified) without
+   * downloading its contents, via the S3-compatible HeadObject API. Returns
+   * `null` if the object does not exist.
+   *
+   * @param key  Path on the disk (e.g. "reports/2026-01/data.json")
+   */
+  headObject(key: string): Promise<ObjectMetadata | null>;
+  /** Whether an object exists on the disk (a HeadObject that maps 404 → false). */
+  objectExists(key: string): Promise<boolean>;
+  /**
+   * Write an object to the disk via the S3-compatible API. Handles any size:
+   * bodies at or below `multipartThreshold` (defaults to `partSize`, i.e.
+   * 16 MiB) go through a single PutObject request; larger bodies are uploaded as
+   * a multipart upload — split into `partSize` parts, uploaded with bounded
+   * `concurrency` (default 4), and assembled. A failed part aborts the upload so
+   * nothing is left half-staged. For manual control over the multipart
+   * lifecycle, use the {@link multipart} namespace.
+   *
+   * Faster than exec for large files — no container overhead, no command-length
+   * limits. Returns the entity tag the server assigned (a multipart upload's tag
+   * is S3's `md5(concat(partMd5s))-N` form rather than a plain MD5).
+   *
+   * @param key      Path on the disk (e.g. "reports/2026-01/data.json")
+   * @param body     Contents as a string, Uint8Array/Buffer, or ArrayBuffer
+   * @param options  Either a content-type string, or {@link PutObjectOptions}
+   *                 (`contentType`, `multipartThreshold`, `partSize`,
+   *                 `concurrency`). Content type defaults to
+   *                 "application/octet-stream".
+   */
+  putObject(key: string, body: string | Uint8Array | ArrayBuffer, options?: string | PutObjectOptions): Promise<PutObjectResult>;
+  /**
+   * Upload a large body through the multipart lifecycle: split into `partSize`
+   * parts, upload them with bounded concurrency, then complete — aborting the
+   * upload if any part fails so nothing is left half-staged. @internal
+   */
+  private _putMultipart;
+  /**
+   * Append bytes to an object via the S3-compatible PutObject append extension
+   * (`?append=true`). If the object already exists the bytes are appended to it;
+   * if it doesn't, it is created. Returns the entity tag of the full object
+   * after the append.
+   *
+   * Each call may append at most 1 MiB — the server rejects a larger body with
+   * `EntityTooLarge`. To grow an object past that, append in chunks (or use
+   * {@link putObject} for a one-shot large write).
+   *
+   * Unlike most operations this is NOT auto-retried on a transient error:
+   * append isn't idempotent, so retrying a succeeded-but-unacknowledged append
+   * would duplicate the bytes. On a transient failure, re-append yourself only
+   * after confirming the object's size.
+   *
+   * @param key          Path on the disk (e.g. "logs/app.log")
+   * @param body         Bytes to append (string, Uint8Array/Buffer, or ArrayBuffer)
+   * @param contentType  MIME type, applied only when the object is newly created.
+   */
+  appendObject(key: string, body: string | Uint8Array | ArrayBuffer, contentType?: string): Promise<PutObjectResult>;
+  /**
+   * Delete an object from the disk via the S3-compatible DeleteObject API.
+   * Idempotent: deleting a key that doesn't exist resolves successfully, per
+   * S3 semantics.
+   *
+   * @param key  Path on the disk (e.g. "project/dist/server.cjs")
+   */
+  deleteObject(key: string): Promise<void>;
+  /**
+   * List objects on the disk via the S3-compatible ListObjectsV2 API. By
+   * default this follows continuation tokens until the listing is exhausted and
+   * returns every matching key. Use `limit` to cap the total, `singlePage` for a
+   * single request, or {@link listObjectsPages} to stream pages without loading
+   * everything into memory.
+   *
+   * @param prefix  Only return keys beginning with this prefix (omit for all).
+   * @param opts    Listing and pagination options.
+   */
+  listObjects(prefix?: string, opts?: ListObjectsOptions): Promise<ListObjectsResult>;
+  /**
+   * Yield ListObjectsV2 pages lazily, following continuation tokens. A
+   * memory-friendly way to process a large listing without materializing it:
+   *
+   * ```ts
+   * for await (const page of disk.listObjectsPages("logs/")) {
+   *   for (const obj of page.objects) process(obj);
+   * }
+   * ```
+   *
+   * @param prefix  Only return keys beginning with this prefix (omit for all).
+   * @param opts    Listing options (`limit` / `singlePage` are ignored here —
+   *                control your own loop).
+   */
+  listObjectsPages(prefix?: string, opts?: ListObjectsOptions): AsyncGenerator<ListObjectsResult>;
+  /** Fetch a single ListObjectsV2 page. @internal */
+  private _listObjectsPage;
+  /**
+   * Delete up to many objects in a single S3-compatible DeleteObjects request.
+   * Unlike {@link deleteObject}, failures are reported per key rather than
+   * thrown: the result's `deleted` lists the keys that were removed and
+   * `errors` lists the ones that weren't (with the server's code/message). A
+   * key that didn't exist still counts as deleted, per S3 semantics.
+   *
+   * The server caps a single request at 1000 keys; this method transparently
+   * splits larger inputs into 1000-key batches and merges the results.
+   *
+   * @param keys  Object keys to delete.
+   * @param opts  `quiet` suppresses the per-key success list server-side.
+   */
+  deleteObjects(keys: string[], opts?: DeleteObjectsOptions): Promise<DeleteObjectsResult>;
+  /**
+   * The advanced, opt-in multipart-upload API. Drive the raw lifecycle
+   * yourself — `create` → `uploadPart` → `complete` (or `abort`), plus
+   * `listParts` / `listUploads`. Most callers don't need this: {@link putObject}
+   * runs the whole lifecycle automatically for large bodies. Reach for it only
+   * when you need manual control (e.g. uploading parts from separate processes),
+   * and note you then own part-size, memory, and concurrency management.
+   */
+  get multipart(): DiskMultipart;
+  /**
+   * Send a single request to the disk's S3-compatible endpoint. This reuses the
+   * control-plane client purely for its credential and transport — the same
+   * `Authorization` header is sent and verified by the same code server-side —
+   * pointed at the S3 host. Returns the response status and fully-buffered body
+   * so callers can inspect both regardless of the verb used.
+   *
+   * The S3 routes (`/{diskId}/{key}` for objects, `/{diskId}` for the bucket)
+   * are not part of the typed control-plane API, so the path and per-request
+   * options are passed untyped. An empty `key` targets the bucket itself (used
+   * by listObjects).
+   *
+   * @internal
+   */
+  private _s3Request;
+  /**
+   * Connect to this disk's data plane via the native ArchilClient.
+   *
+   * Requires the native module to be available (platform-specific .node binary).
+   */
+  mount(opts?: MountOptions): Promise<unknown>;
+}
+/**
+ * The advanced, opt-in multipart-upload namespace, reached via {@link Disk.multipart}.
+ * Drives the raw S3 multipart lifecycle — `create` → `uploadPart` → `complete`
+ * (or `abort`), plus `listParts` / `listUploads`. Prefer {@link Disk.putObject},
+ * which runs this lifecycle automatically for large bodies; use this only when
+ * you need manual control, in which case you own part-size, memory, and
+ * concurrency management.
+ */
+declare class DiskMultipart {
+  private readonly diskId;
+  private readonly s3Request;
+  /** @internal */
+  constructor(diskId: string, s3Request: S3RequestFn);
+  /**
+   * Start a multipart upload (CreateMultipartUpload) and return its `uploadId`.
+   *
+   * @param key          Path on the disk the finished object will live at.
+   * @param contentType  MIME type to store the object with.
+   */
+  create(key: string, contentType?: string): Promise<MultipartUpload>;
+  /**
+   * Upload one part (UploadPart) and return its entity tag, which you must
+   * collect (with its part number) and pass to {@link complete}. Every part
+   * except the last must be at least 5 MiB.
+   *
+   * @param key         The upload's object key.
+   * @param uploadId    The id from {@link create}.
+   * @param partNumber  1-based part number (1..=10000).
+   * @param body        Part contents as a string, Uint8Array/Buffer, or ArrayBuffer.
+   */
+  uploadPart(key: string, uploadId: string, partNumber: number, body: string | Uint8Array | ArrayBuffer): Promise<UploadPart>;
+  /**
+   * Finish a multipart upload (CompleteMultipartUpload), assembling the listed
+   * parts into one object. Parts are sorted by part number before submission
+   * (the server requires strictly-increasing order).
+   *
+   * Unlike the other operations this is NOT auto-retried on a transient error:
+   * the gateway isn't idempotent for completion, so a retry after a
+   * successful-but-unacknowledged complete would return a spurious NoSuchUpload.
+   * On a transient failure, re-drive completion yourself only after confirming
+   * the object isn't already present.
+   *
+   * @param key       The upload's object key.
+   * @param uploadId  The id from {@link create}.
+   * @param parts     The `{ partNumber, etag }` pairs from {@link uploadPart}.
+   */
+  complete(key: string, uploadId: string, parts: UploadPart[]): Promise<CompletedMultipartUpload>;
+  /**
+   * Abort a multipart upload (AbortMultipartUpload), discarding every staged
+   * part. Idempotent against an upload that's already gone (404 / NoSuchUpload
+   * resolves successfully).
+   *
+   * @param key       The upload's object key.
+   * @param uploadId  The id from {@link create}.
+   */
+  abort(key: string, uploadId: string): Promise<void>;
+  /**
+   * List the parts already uploaded for an in-progress upload (ListParts).
+   * Returns a single page; follow `nextPartNumberMarker` (when `isTruncated`)
+   * to page through the rest.
+   *
+   * @param key       The upload's object key.
+   * @param uploadId  The id from {@link create}.
+   * @param opts      `maxParts` / `partNumberMarker` pagination controls.
+   */
+  listParts(key: string, uploadId: string, opts?: ListPartsOptions): Promise<PartListing>;
+  /**
+   * List in-progress multipart uploads on the disk (ListMultipartUploads).
+   * Returns a single page; follow `nextKeyMarker` / `nextUploadIdMarker` (when
+   * `isTruncated`) for the rest.
+   *
+   * @param opts  Prefix/delimiter filter and pagination markers.
+   */
+  listUploads(opts?: ListMultipartUploadsOptions): Promise<MultipartUploadListing>;
+}
+/**
+ * Choose the part size for a `totalBytes` multipart upload. Returns
+ * `requestedPartSize` unless splitting at that size would exceed the server's
+ * 10,000-part cap, in which case it grows the part size (rounded up to a whole
+ * MiB) so the body fits in ≤ 10,000 parts — mirroring boto3's chunk-size
+ * adjustment. Parts only ever get larger, so they stay above the 5 MiB floor.
+ */
+declare function effectiveUploadPartSize(totalBytes: number, requestedPartSize: number): number;
+//#endregion
+export { AwsStsUser as A, ExecRequest as B, S3Object as C, effectiveUploadPartSize as D, UploadPart as E, DiskMetrics as F, MountConfigResponse as G, GrepMatch as H, DiskResponse as I, S3CompatibleMount as J, MountResponse as K, DiskStatus as L, ConnectedClient as M, CreateApiTokenRequest as N, ApiTokenResponse as O, CreateDiskRequest as P, ApiClient as Q, DiskUser as R, PutObjectResult as S, ShareUrlResult as T, GrepStoppedReason as U, GCSMount as V, MountConfig as W, TokenUser as X, S3Mount as Y, FileSystem as Z, MultipartUploadSummary as _, Disk as a, PartListing as b, GrepOptions as c, ListObjectsOptions as d, ListObjectsResult as f, MultipartUploadListing as g, MultipartUpload as h, DeleteObjectsResult as i, AzureBlobMount as j, AuthorizedUser as k, GrepResult as l, MountOptions as m, DeleteObjectsError as n, DiskMultipart as o, ListPartsOptions as p, R2Mount as q, DeleteObjectsOptions as r, ExecResult as s, CompletedMultipartUpload as t, ListMultipartUploadsOptions as u, ObjectMetadata as v, ShareUrlOptions as w, PutObjectOptions as x, PartInfo as y, ExecDiskResult as z };