@dropthis/cli 0.9.3 → 0.11.0

package/node_modules/@dropthis/node/README.md

@@ -17,8 +17,14 @@ const dropthis = new Dropthis({ apiKey: "sk_..." });
 const { data, error } = await dropthis.drops.publish("<h1>Hello</h1>");
 
 console.log(data.url); // https://abc123.dropthis.app
+console.log(data.id);  // drop_… — keep this; it's how you update or delete later
 ```
 
+> **Keep the `drop_…` id.** `publish()` never takes an id — every call creates a NEW drop.
+> To change something already published, pass the id from the publish response to
+> `drops.updateContent()` (the files at the URL) or `drops.updateSettings()` (title,
+> visibility, expiry, …). Lost the id? Recover it from the URL with `drops.resolve()`.
+
 ## Usage
 
 ### Publish an HTML string
@@ -45,7 +51,7 @@ const { data } = await dropthis.drops.publish("./dist");
 const { data } = await dropthis.drops.publish("./dist", {
   title: "Q4 Report",
   visibility: "unlisted",
-  password: "s3cret",
+  noindex: true,
   expiresAt: "2026-12-31T00:00:00Z",
 });
 ```
@@ -66,6 +72,71 @@ const updated = await dropthis.drops.updateContent(created.data.id, "./dist-v2",
 await dropthis.drops.updateSettings("drop_abc123", { title: "New title" });
 ```
 
+### Resolve a URL back to its drop
+
+Lost the `drop_…` id? Resolve the drop's URL (or bare slug) back to the drop. The slug is
+parsed client-side from the first hostname label of a dropthis hostname
+(`<slug>.dropthis.app`, or `<slug>.` + your configured `baseUrl` host), then matched against
+your own drops via `GET /drops?slug=`. Custom-domain URLs are not resolvable yet — they are
+rejected client-side with an `invalid_drop_url` error, without hitting the API.
+
+```typescript
+const { data } = await dropthis.drops.resolve("https://my-report.dropthis.app/");
+
+if (data) {
+  console.log(data.id); // drop_… — use this for updateContent/updateSettings/delete
+} else {
+  // none of your drops has that slug
+}
+```
+
+### Read back what a drop is serving
+
+`drops.getContent()` is the owner-side read-back (it works regardless of any viewer
+password). By default it returns a JSON manifest of the current deployment's files;
+pass `path` to download one file's exact stored bytes.
+
+```typescript
+// Manifest of the current deployment
+const manifest = await dropthis.drops.getContent("drop_abc123");
+console.log(manifest.data.files); // [{ path, contentType, sizeBytes }, …]
+
+// One file's bytes (and a text() helper)
+const file = await dropthis.drops.getContent("drop_abc123", { path: "index.html" });
+console.log(file.data.contentType); // "text/html"
+console.log(file.data.text());      // "<h1>…"
+
+// A historical (even superseded) deployment — this is also the rollback path:
+// download the old version's files and republish them with updateContent().
+const old = await dropthis.drops.getContent("drop_abc123", {
+  deploymentId: "dep_xyz789",
+  path: "index.html",
+});
+```
+
+### Safe concurrent edits with ifRevision
+
+Every drop response carries a `revision`. Pass it back as `ifRevision` on
+`updateContent()` / `updateSettings()` to make the update conditional: if someone else
+changed the drop in between, the API answers 409 instead of clobbering, and the error
+exposes the server's `currentRevision` so you can re-read and retry.
+
+```typescript
+// 1. Read
+const drop = await dropthis.drops.get("drop_abc123");
+
+// 2. Edit locally (e.g. via getContent read-back), then
+// 3. Update conditionally
+const result = await dropthis.drops.updateContent(drop.data.id, "./dist-v2", {
+  ifRevision: drop.data.revision,
+});
+
+if (result.error?.statusCode === 409) {
+  console.log("Drop changed underneath us; server is at revision", result.error.currentRevision);
+  // re-read with drops.get(), merge, retry with the fresh revision
+}
+```
+
 ## Supported inputs
 
 The `drops.publish()` and `drops.updateContent()` methods accept:
@@ -82,7 +153,7 @@ The `drops.publish()` and `drops.updateContent()` methods accept:
 
 Drop **settings** (title, visibility, password, noindex, expiresAt, metadata) go in the second `options` argument, not in the input object.
 
-All inputs are uploaded through staged presigned URLs. The SDK handles this transparently.
+All inputs are uploaded through staged presigned URLs — one signed PUT per file, up to 5 files in parallel. The SDK handles this transparently.
 
 ### Explicit input examples
 
@@ -174,6 +245,9 @@ const dropthis = new Dropthis("sk_...");
 ```typescript
 await dropthis.drops.list({ limit: 20 });
 await dropthis.drops.get("drop_abc123");
+await dropthis.drops.resolve("https://my-report.dropthis.app/"); // URL/slug → drop (or null)
+await dropthis.drops.getContent("drop_abc123");                  // manifest of served files
+await dropthis.drops.getContent("drop_abc123", { path: "index.html" }); // one file's bytes
 await dropthis.drops.updateSettings("drop_abc123", { title: "Updated" });
 await dropthis.drops.delete("drop_abc123");
 ```
@@ -209,7 +283,7 @@ await dropthis.uploads.create({
   files: [{ path: "index.html", contentType: "text/html", sizeBytes: 1024 }],
 });
 await dropthis.uploads.get("upl_abc123");
-await dropthis.uploads.complete("upl_abc123", { files: {} });
+await dropthis.uploads.complete("upl_abc123"); // no body — server verifies against the manifest
 await dropthis.uploads.cancel("upl_abc123");
 ```
 
@@ -218,7 +292,7 @@ await dropthis.uploads.cancel("upl_abc123");
 ```typescript
 await dropthis.auth.requestEmailOtp({ email: "you@example.com" });
 await dropthis.auth.verifyEmailOtp({ email: "you@example.com", code: "123456" });
-await dropthis.auth.logout();
+await dropthis.auth.logout(); // 204 No Content — data is null
 ```
 
 ### apiKeys
@@ -226,17 +300,76 @@ await dropthis.auth.logout();
 ```typescript
 await dropthis.apiKeys.create({ label: "CI" });
 await dropthis.apiKeys.list();
-await dropthis.apiKeys.delete("key_abc123");
+await dropthis.apiKeys.delete("key_abc123"); // 204 No Content — data is null
 ```
 
 ### account
 
 ```typescript
-await dropthis.account.get();
+const { data } = await dropthis.account.get();
+// data.limits carries your plan's limits — use them to size a publish first:
+// { name, maxSizeBytes, defaultTtlSeconds, maxStorageBytes }
+
 await dropthis.account.update({ displayName: "Jane Doe" });
 await dropthis.account.delete();
 ```
 
+### domains
+
+Custom domains let you serve drops on your own hostname instead of the shared pool. There are two
+modes: **path** (many drops at `hostname/{slug}/`) and **dedicated** (one drop at the hostname root).
+
+```typescript
+// 1. Connect the domain — returns DNS instructions (status: "pending_dns")
+const { data: domain } = await dropthis.domains.connect({
+  hostname: "drops.example.com",
+  mode: "path",
+});
+
+// 2. Create the CNAME at your DNS provider:
+//    drops.example.com  CNAME  edge.dropthis.app
+const dnsRecord = domain.dns[0];
+// dnsRecord.name  → "drops.example.com"
+// dnsRecord.value → "edge.dropthis.app"
+
+// 3. Verify — call repeatedly until status is "live"
+const { data: verified } = await dropthis.domains.verify("drops.example.com");
+// Use verified.dns[0].retryAfter (seconds) as the polling interval while status !== "live"
+// verified.status → "live"
+
+// 4. Publish to the custom domain (path mode: specify a vanity slug, or omit for a random one)
+const { data: drop } = await dropthis.drops.publish("<h1>Hello</h1>", {
+  domain: "drops.example.com",
+  slug: "summer-sale",
+});
+// drop.url → "https://drops.example.com/summer-sale/"
+```
+
+Other domain operations:
+
+```typescript
+await dropthis.domains.list();
+await dropthis.domains.get("drops.example.com");
+
+// Repoint a dedicated domain to a different drop
+await dropthis.domains.update("bio.example.com", { dropId: "drop_abc123" });
+
+// Set a path-mode domain as the account's publish default
+await dropthis.domains.update("drops.example.com", { default: true });
+
+// Delete (remove your DNS CNAME after this to prevent re-claim by another account)
+await dropthis.domains.delete("drops.example.com");
+```
+
+## Pricing tiers
+
+- **Free ($0)** — drops expire after 7 days, 5 MB per drop, dropthis badge.
+- **Personal ($5/mo)** — drops stay live while subscribed (no expiry), no badge, 100 MB per drop, 2 GB account storage.
+- **Pro ($19/mo)** — everything in Personal plus password protection, custom domains, and analytics.
+
+`account.get().data.limits` reflects your active tier. Note: password protection ships
+with Pro and is not enabled on any tier yet — the API rejects the `password` option until then.
+
 ## Cloudflare Workers (edge)
 
 Use the fs-free entry point for Cloudflare Workers and other edge runtimes. It does not import `node:fs`, `node:path`, or `node:crypto`.
@@ -250,7 +383,7 @@ const { data, error } = await dropthis.drops.publish("<h1>Hello from the edge</h
 
 `DropthisEdge` accepts the in-memory subset of `PublishInput`: inline strings, `Uint8Array`, `URL`, and the explicit `{ kind: "content" }`, `{ kind: "source_url" }`, and `{ kind: "files" }` forms. Local file paths and `string[]` path arrays are not supported (no filesystem on the edge).
 
-`DropthisEdge` exposes the drop lifecycle through `drops.publish(input, options?)`, `drops.updateContent(dropId, input, options?)`, `drops.updateSettings`, `drops.get`, `drops.list`, and `drops.delete`, plus the `deployments`, `account`, and `apiKeys` resource accessors — the same surface as the Node client.
+`DropthisEdge` exposes the drop lifecycle through `drops.publish(input, options?)`, `drops.updateContent(dropId, input, options?)`, `drops.updateSettings`, `drops.get`, `drops.list`, `drops.resolve`, `drops.getContent`, and `drops.delete`, plus the `deployments`, `account`, `apiKeys`, and `domains` resource accessors — the same surface as the Node client.
 
 ## Types
 
@@ -258,12 +391,18 @@ Key types exported from the package:
 
 ```typescript
 import type {
+  AccountLimits,
+  AccountResponse,
   DropthisClientOptions,
   DropthisResult,
   DropthisErrorResponse,
   DropResponse,
   DropDeploymentResponse,
   DropOptions,
+  DeploymentContentManifest,
+  DeploymentContentFile,
+  DropContentFile,
+  GetContentOptions,
   PrepareOptions,
   RequestControls,
   PublishOptions,

package/node_modules/@dropthis/node/dist/{drops-BWA0D1IW.d.cts → drops-DEJcU6qw.d.cts}

@@ -153,6 +153,17 @@ type ApiKeyCreatedResponse = ApiKeyResponse & {
     accountId?: string | null;
     isNewAccount?: boolean;
 };
+/** Active plan tier limits — use these to size a publish before uploading. */
+type AccountLimits = {
+    /** Plan tier the limits apply to. */
+    name: string;
+    /** Maximum size of a single drop in bytes. */
+    maxSizeBytes: number;
+    /** Drop lifetime in seconds before expiry; null means drops are permanent. */
+    defaultTtlSeconds: number | null;
+    /** Total account storage cap in bytes; null means no account-level cap. */
+    maxStorageBytes: number | null;
+};
 type AccountResponse = {
     id: string;
     email: string;
@@ -160,6 +171,7 @@ type AccountResponse = {
     plan: string;
     status: string;
     createdAt: string;
+    limits: AccountLimits;
 };
 type ListDropsParams = {
     cursor?: string | null;
@@ -177,7 +189,8 @@ type CreateUploadSessionRequest = {
     entry?: string | null;
 };
 type UploadTarget = {
-    strategy: "single_put" | "multipart";
+    /** Always `single_put` — one signed PUT per file is the upload contract. */
+    strategy: "single_put";
     url: string;
     headers: Record<string, string>;
     expiresAt: string;
@@ -210,14 +223,6 @@ type CreateUploadSessionResponse = {
     files: CreateUploadSessionFileResponse[];
     nextAction?: Action | null;
 };
-type CompleteUploadSessionRequest = {
-    files?: Record<string, {
-        parts?: Array<{
-            partNumber: number;
-            etag: string;
-        }> | null;
-    }>;
-};
 type DropOptions = {
     /** Drop title. */
     title?: string;
@@ -233,6 +238,20 @@ type DropOptions = {
     entry?: string;
     /** Attach JSON key-value pairs, e.g. `{ source: "ci" }`. */
     metadata?: Record<string, unknown>;
+    /**
+     * Hostname of a custom domain connected to this account (must be live — see
+     * `client.domains`). Path-mode domains serve the drop at `https://{domain}/{slug}/`;
+     * dedicated domains serve it at the root and conflict (409) once occupied. Omit to
+     * use the account's default path domain if one exists, else the shared pool.
+     */
+    domain?: string | null;
+    /**
+     * Vanity slug — only valid when the target is a path-mode custom domain. 1–63
+     * lowercase letters/digits/hyphens (no leading/trailing/double hyphen). Taken slugs
+     * are auto-suffixed; omit for a random slug. Setting this on the shared pool returns
+     * 422.
+     */
+    slug?: string | null;
 };
 type PrepareOptions = {
     /** Glob patterns to ignore when publishing directories. */
@@ -281,6 +300,119 @@ type PublishInput = string | string[] | URL | Uint8Array | {
     files: PublishFileInput[];
     entry?: string;
 };
+/** Structured next-step hint returned by domain operations (and publish). */
+type NextHint = {
+    action: string;
+    message: string;
+};
+/** One DNS record instruction or diagnostic for a custom domain. */
+type DnsRecord = {
+    /** Purpose of the record, e.g. "routing". */
+    purpose: string;
+    /** DNS record type, e.g. "CNAME". */
+    type: string;
+    /** The DNS name to create the record for. */
+    name: string;
+    /** The value the record must point at. */
+    value: string;
+    /** Current DNS status: "missing" | "ok" | "mismatch". */
+    status: "missing" | "ok" | "mismatch";
+    /** What DoH currently resolves for this record (verify only). */
+    observed?: string | null;
+    /** Specific guidance for fixing this record. */
+    hint?: string | null;
+    /** Seconds to wait before retrying verify while DNS/cert propagates. */
+    retryAfter?: number | null;
+};
+/** Full domain resource representation. */
+type DomainResponse = {
+    object: "domain";
+    /** Stable domain identifier. */
+    id: string;
+    /** Canonical hostname registered with dropthis. */
+    hostname: string;
+    /** Mount mode: "path" (many drops at hostname/{slug}/) or "dedicated" (one drop at hostname/). */
+    mode: "path" | "dedicated";
+    /** Lifecycle status: "pending_dns" | "verifying" | "live" | "failed". */
+    status: "pending_dns" | "verifying" | "live" | "failed";
+    /** Reason for failure status. */
+    failureReason?: string | null;
+    /** Whether this is the account's default publish domain. */
+    default: boolean;
+    /** Mounted drop id (dedicated mode only). */
+    dropId?: string | null;
+    /** DNS records required for this domain. */
+    dns: DnsRecord[];
+    /** Creation timestamp. */
+    createdAt: string;
+    /** When the domain first reached "live" status. */
+    verifiedAt?: string | null;
+    /** Structured next-step hints for the agent. */
+    next: NextHint[];
+};
+/** List of domains for the account. */
+type DomainListResponse = {
+    object: "domain.list";
+    /** Domains connected to this account. */
+    domains: DomainResponse[];
+};
+/** Response body for a successful domain deletion. */
+type DomainDeletedResponse = {
+    object: "domain.deleted";
+    /** Id of the deleted domain. */
+    id: string;
+    /** Hostname of the deleted domain. */
+    hostname: string;
+    /** Dangling-CNAME risk warning (always present; instructs you to remove the DNS record). */
+    warning: string;
+};
+/** One readable file in a deployment's content manifest. */
+type DeploymentContentFile = {
+    /** File path within the deployment, relative to its root. */
+    path: string;
+    /** Stored MIME type the file is served with. */
+    contentType: string;
+    /** Stored file size in bytes. */
+    sizeBytes: number;
+};
+/**
+ * Manifest of one deployment's readable files (content read-back).
+ * Fetch a single file's bytes with `drops.getContent(dropId, { path })`.
+ */
+type DeploymentContentManifest = {
+    /** Parent drop identifier. */
+    dropId: string;
+    /** Deployment identifier. */
+    deploymentId: string;
+    /** Content revision of this deployment. */
+    revision: number;
+    /** Deployment lifecycle status. */
+    status: string;
+    /** Total deployment size in bytes. */
+    sizeBytes: number;
+    /** Entry path served at the drop root. */
+    entry?: string | null;
+    /** Readable files in this deployment; pass files[].path as `path` to download one. */
+    files: DeploymentContentFile[];
+};
+/** Options for `drops.getContent()`. */
+type GetContentOptions = {
+    /** Read a historical deployment instead of the current one. */
+    deploymentId?: string;
+    /** Download this single file's raw stored bytes instead of the JSON manifest. */
+    path?: string;
+};
+/** A single file downloaded via `drops.getContent(dropId, { path })`. */
+type DropContentFile = {
+    /** The requested file path. */
+    path: string;
+    /** Stored MIME type the file is served with (from the response Content-Type). */
+    contentType: string | null;
+    /** Exact stored bytes. */
+    bytes: Uint8Array;
+    /** Decode the bytes as UTF-8 text. */
+    text(): string;
+};
 
 declare class Transport {
     readonly apiKey: string | undefined;
@@ -292,6 +424,17 @@ declare class Transport {
     putSignedUrl(url: string, body: Uint8Array | Blob | ReadableStream, headers: Record<string, string>): Promise<DropthisResult<{
         etag: string | null;
     }>>;
+    /**
+     * Authenticated GET that returns the raw response bytes untouched (no JSON parsing,
+     * no case conversion). Error responses are still parsed as problem+json. Used for
+     * content read-back (`drops.getContent` with a file path).
+     */
+    requestBytes(path: string, options?: RequestOptions & {
+        params?: Record<string, string | number | boolean | null | undefined>;
+    }): Promise<DropthisResult<{
+        bytes: Uint8Array;
+        contentType: string | null;
+    }>>;
     request<T>(method: string, path: string, options?: RequestOptions & {
         body?: unknown;
         bodyCase?: "snake" | "raw";
@@ -372,9 +515,8 @@ declare class ApiKeysResource {
     create(input: {
         label: string;
     }): Promise<DropthisResult<ApiKeyCreatedResponse>>;
-    delete(keyId: string): Promise<DropthisResult<{
-        ok: true;
-    }>>;
+    /** Revoke an API key. 204 No Content — data is null on success. */
+    delete(keyId: string): Promise<DropthisResult<null>>;
 }
 
 declare class DeploymentsResource {
@@ -384,6 +526,45 @@ declare class DeploymentsResource {
     get(dropId: string, deploymentId: string): Promise<DropthisResult<DropDeploymentResponse>>;
 }
 
+declare class DomainsResource {
+    private readonly transport;
+    constructor(transport: Transport);
+    /**
+     * Connect a custom domain to the account. Returns the domain in `pending_dns` status with
+     * DNS instructions. Idempotent on (account, hostname) — re-connecting an already-connected
+     * domain returns the existing row. POST /domains.
+     */
+    connect(input: {
+        hostname: string;
+        mode: "path" | "dedicated";
+    }): Promise<DropthisResult<DomainResponse>>;
+    /** List all custom domains connected to this account. GET /domains. */
+    list(): Promise<DropthisResult<DomainListResponse>>;
+    /** Get a domain by its stable id or hostname. GET /domains/{id_or_hostname}. */
+    get(idOrHostname: string): Promise<DropthisResult<DomainResponse>>;
+    /**
+     * Trigger a DNS + Cloudflare verification check. Returns the domain with updated status and
+     * per-record diagnostics. If DNS is still propagating, `dns[].retryAfter` tells you when to
+     * re-call. POST /domains/{id_or_hostname}/verify.
+     */
+    verify(idOrHostname: string): Promise<DropthisResult<DomainResponse>>;
+    /**
+     * Update a domain's `dropId` (dedicated mode: repoint to a different drop) or `default`
+     * flag (path mode only: set/clear the account's default publish domain). Mode is immutable
+     * — delete and reconnect to change it. PATCH /domains/{id_or_hostname}.
+     */
+    update(idOrHostname: string, input: {
+        dropId?: string | null;
+        default?: boolean | null;
+    }): Promise<DropthisResult<DomainResponse>>;
+    /**
+     * Delete a custom domain and remove all its routes. The response includes a dangling-CNAME
+     * warning — remove the DNS record after deleting so another account cannot re-claim the
+     * hostname. DELETE /domains/{id_or_hostname}.
+     */
+    delete(idOrHostname: string): Promise<DropthisResult<DomainDeletedResponse>>;
+}
+
 declare class CursorPage<T> implements ListPage<T> {
     readonly object: "list";
     readonly data: T[];
@@ -410,8 +591,15 @@ declare class CursorPage<T> implements ListPage<T> {
  */
 declare class DropsResource<TInput = PublishInput> {
     private readonly transport;
-    private readonly resolve;
-    constructor(transport: Transport, resolve: PublishInputResolver<TInput>);
+    private readonly resolveInput;
+    private parentHosts?;
+    constructor(transport: Transport, resolveInput: PublishInputResolver<TInput>);
+    /**
+     * Hostnames the SDK can attribute to dropthis for slug parsing: the canonical
+     * viewer domain plus the configured baseUrl's host (covers staging/self-hosted
+     * setups where drops are served under the API's own domain).
+     */
+    private allowedParentHosts;
     /**
      * Publish content to a NEW permanent public URL; returns the created drop (with its `drop_…` id).
      * Use to publish / share / post / put online / make public a report, dashboard, site, or file.
@@ -432,14 +620,44 @@ declare class DropsResource<TInput = PublishInput> {
     list(params?: ListDropsParams): Promise<DropthisResult<CursorPage<DropResponse>>>;
     /** Fetch one drop by its `drop_…` id (not the slug/URL). GET /drops/{id}. */
     get(dropId: string): Promise<DropthisResult<DropResponse>>;
+    /**
+     * Resolve a drop URL (or bare slug) back to the drop — the way to recover a lost
+     * `drop_…` id. The slug is parsed client-side from the first hostname label of a
+     * dropthis-attributable hostname (`https://<slug>.dropthis.app/…`, or `<slug>.` +
+     * the configured baseUrl's host), then matched owner-scoped via GET /drops?slug=.
+     * Returns the drop, or `data: null` when no drop of yours has that slug.
+     * Custom-domain URLs are rejected client-side with `invalid_drop_url` — they are
+     * not resolvable yet.
+     */
+    resolve(urlOrSlug: string): Promise<DropthisResult<DropResponse | null>>;
+    /**
+     * Read back what a drop is serving (owner-only; works regardless of any viewer
+     * password). By default returns the JSON manifest of the CURRENT deployment's files;
+     * pass `deploymentId` to read a historical (even superseded) deployment — downloading
+     * an old version's files and republishing them via {@link updateContent} is the
+     * rollback path. Pass `path` (one of the manifest's `files[].path` values) to download
+     * that file's exact stored bytes instead. GET /drops/{id}/content.
+     */
+    getContent(dropId: string, options: GetContentOptions & {
+        path: string;
+    }): Promise<DropthisResult<DropContentFile>>;
+    getContent(dropId: string, options?: Omit<GetContentOptions, "path">): Promise<DropthisResult<DeploymentContentManifest>>;
     /**
      * Change an EXISTING drop's settings — title, visibility, password, noindex, expiry,
-     * metadata — by its `drop_…` id. Does not touch content; replace that with {@link updateContent}.
-     * Idempotent. PATCH /drops/{id}.
+     * metadata, domain, or slug — by its `drop_…` id. Does not touch content; replace that
+     * with {@link updateContent}. Idempotent. PATCH /drops/{id}.
+     *
+     * **`domain`** — move the drop to a different custom domain (must be live). Pass `null` to
+     * move the drop back to the shared pool (unmount from its current domain).
+     *
+     * **`slug`** — rename the vanity slug on a path-mode custom domain. Only valid when the drop
+     * lives on a path-mode domain. Unlike {@link publish} (which auto-suffixes taken slugs),
+     * `updateSettings` returns 409 on a slug conflict and never auto-suffixes — your code must
+     * catch 409 and retry with a different slug. Passing `slug` on the shared pool returns 422.
      */
     updateSettings(dropId: string, options?: DropOptions & RequestControls): Promise<DropthisResult<DropResponse>>;
     /** Permanently delete a drop and its public URL by its `drop_…` id. DELETE /drops/{id}. */
     delete(dropId: string): Promise<DropthisResult<null>>;
 }
 
-export { AccountResource as A, type UploadTarget as B, type CompleteUploadSessionRequest as C, DeploymentsResource as D, type EmailOtpResponse as E, type InMemoryPublishInput as I, type Limitations as L, type PrepareOptions as P, type RequestControls as R, type SessionResponse as S, type TierInfo as T, type UpdateContentOptions as U, type ActionResolve as a, ApiKeysResource as b, type CreateUploadSessionRequest as c, type CreateUploadSessionResponse as d, CursorPage as e, type DropAction as f, type DropDeploymentResponse as g, type DropOptions as h, type DropResponse as i, DropsResource as j, type DropthisClientOptions as k, type DropthisErrorResponse as l, type DropthisResult as m, type ListDeploymentsParams as n, type ListDeploymentsResponse as o, type ListPage as p, type PreparedPublishRequest as q, type PreparedUploadFile as r, type PublishFileInput as s, type PublishInput as t, type PublishOptions as u, type RequestOptions as v, Transport as w, type UploadManifestFile as x, type UploadSessionFileResponse as y, type UploadSessionResponse as z };
+export { type AccountLimits as A, type PreparedUploadFile as B, type CreateUploadSessionRequest as C, type DeploymentContentFile as D, type EmailOtpResponse as E, type PublishFileInput as F, type GetContentOptions as G, type PublishInput as H, type InMemoryPublishInput as I, type PublishOptions as J, type RequestOptions as K, type Limitations as L, Transport as M, type NextHint as N, type UploadManifestFile as O, type PrepareOptions as P, type UploadSessionFileResponse as Q, type RequestControls as R, type SessionResponse as S, type TierInfo as T, type UpdateContentOptions as U, type UploadSessionResponse as V, type UploadTarget as W, AccountResource as a, type AccountResponse as b, type ActionResolve as c, ApiKeysResource as d, type CreateUploadSessionResponse as e, CursorPage as f, type DeploymentContentManifest as g, DeploymentsResource as h, type DnsRecord as i, type DomainDeletedResponse as j, type DomainListResponse as k, type DomainResponse as l, DomainsResource as m, type DropAction as n, type DropContentFile as o, type DropDeploymentResponse as p, type DropOptions as q, type DropResponse as r, DropsResource as s, type DropthisClientOptions as t, type DropthisErrorResponse as u, type DropthisResult as v, type ListDeploymentsParams as w, type ListDeploymentsResponse as x, type ListPage as y, type PreparedPublishRequest as z };