@shipstatic/ship 2.0.0-beta.16 → 2.0.0-beta.18

package/dist/index.d.ts

@@ -1,7 +1,1710 @@
-import * as _shipstatic_types from '@shipstatic/types';
-import { DeploymentUploadOptions, StaticFile, DeploymentViaType, DeploymentCreateResponse, ListOptions, DeploymentListResponse, Deployment, DeploymentDeleteResponse, DomainSetResult, DomainListResponse, Domain, DomainDeleteResponse, DomainVerifyResponse, DomainDnsResponse, DomainRecordsResponse, DomainShareResponse, DomainValidateResponse, TokenCreateResponse, TokenListResponse, TokenDeleteResponse, Token, AccountGetResponse, PlatformLimits, PingResponse, DeployInput, AccountResource, DeploymentResource, DomainResource, TokenResource, ValidatableFile, FileValidationResult } from '@shipstatic/types';
-export * from '@shipstatic/types';
-export { Account, AccountResource, DEFAULT_API, DeployInput, Deployment, DeploymentResource, Domain, DomainResource, ErrorType, FileValidationStatus as FILE_VALIDATION_STATUS, PingResponse, ShipError, StaticFile, TokenResource, ValidatableFile } from '@shipstatic/types';
+/**
+ * @file Shared TypeScript types, constants, and utilities for the ShipStatic platform.
+ * This package is the single source of truth for all shared data structures.
+ */
+/**
+ * Deployment status constants
+ */
+declare const DeploymentStatus: {
+    readonly PENDING: "pending";
+    readonly SUCCESS: "success";
+    readonly FAILED: "failed";
+    readonly DELETING: "deleting";
+};
+type DeploymentStatusType = (typeof DeploymentStatus)[keyof typeof DeploymentStatus];
+/**
+ * Which client made a deployment — the origin-tracking vocabulary.
+ *
+ * A closed set with many authors: the CLI, the SDK, the dashboard, both MCP
+ * transports, the GitHub Action, the n8n node and the VS Code extension each
+ * name themselves here. It lived in the API's config until 2026-08-06, where
+ * being server-side made it unenforceable in the one direction that matters —
+ * every client wrote a bare string, and a value outside the set was **silently
+ * dropped** by the server, so a typo did not fail anywhere. It stopped
+ * recording where deploys came from and said nothing.
+ */
+declare const DeploymentVia: {
+    readonly WEB: "web";
+    readonly SDK: "sdk";
+    readonly CLI: "cli";
+    readonly MCP: "mcp";
+    readonly GIT: "git";
+    readonly N8N: "n8n";
+    readonly GPT: "gpt";
+    readonly VSC: "vsc";
+};
+type DeploymentViaType = (typeof DeploymentVia)[keyof typeof DeploymentVia];
+/**
+ * Core deployment object - used in both API responses and SDK
+ */
+interface Deployment {
+    /** The deployment hostname (e.g., 'happy-cat-abc1234.shipstatic.com') */
+    readonly deployment: string;
+    /** Full URL to the deployment (e.g., 'https://happy-cat-abc1234.shipstatic.com') */
+    readonly url: string;
+    /** Number of files in this deployment */
+    readonly files: number;
+    /** Total size of all files in bytes */
+    readonly size: number;
+    /** Current deployment status */
+    status: DeploymentStatusType;
+    /** Whether deployment has a ship.json config */
+    readonly config: boolean;
+    /** Whether deployment has a password set */
+    readonly password: boolean;
+    /** Labels for categorization and filtering (lowercase, alphanumeric with separators). Always present, empty array when none. */
+    labels: string[];
+    /**
+     * The client/tool that created this deployment, null if unknown.
+     *
+     * Deliberately wider than {@link DeploymentViaType}: this is stored data,
+     * and rows predate the vocabulary being closed. Narrowing the ENTITY would
+     * be a claim about every row already in the database; narrowing the
+     * REQUEST option ({@link DeploymentUploadOptions.via}) is a claim about
+     * what a client may send, which is ours to make.
+     */
+    readonly via: string | null;
+    /** Unix timestamp (seconds) when deployment was created */
+    readonly created: number;
+    /** Unix timestamp (seconds) when deployment expires, null if never */
+    expires: number | null;
+    /** Full URL to the deployment screenshot (e.g., 'https://screenshots.shipstatic.com/happy-cat-abc1234/a3f2c1b4d5e6f789') */
+    readonly screenshot: string;
+}
+/**
+ * Response from deployment creation. Extends Deployment with one-time fields
+ * only present on creation (not on subsequent GET requests).
+ */
+interface DeploymentCreateResponse extends Deployment {
+    /** Claim URL for public deployments. Present when deployed without credentials. */
+    readonly claim?: string;
+}
+/**
+ * The half of a list response that is identical on every list.
+ *
+ * `GET /<collection>` answers exactly two fields — the collection under its
+ * own plural noun, and this cursor — so the cursor is declared once here and
+ * each response below adds only its noun. `cursor: null` means last page and
+ * is the ENTIRE has-more signal, which is why there is no `has_more`.
+ *
+ * There is deliberately no `total`. A count is an aggregate over a
+ * collection, not a property of a page; producing one would cost a COUNT
+ * beside every page read, which is precisely what keyset pagination exists
+ * to avoid. Counts live on the resource that summarises the collection —
+ * `GET /account`'s `usage` for one caller, `GET /admin/stats` platform-wide.
+ */
+interface ListResponse {
+    /** Opaque cursor from this page; `null` on the last page. */
+    cursor: string | null;
+}
+/**
+ * Pagination options for every list endpoint. The response's `cursor` feeds
+ * the next request; a `null` cursor means the last page. Omitting both
+ * returns the server's default first page.
+ *
+ * A list answers `{ <collection>, cursor }` and nothing else — `cursor`
+ * carries the entire has-more signal, so no redundant boolean, and no
+ * `total`. **A count is an aggregate over a collection, not a property of a
+ * page:** including one makes every read pay for a full scan it did not ask
+ * for, which is precisely the cost keyset pagination exists to avoid.
+ *
+ * Counts therefore live on the summary resource that owns them —
+ * `GET /account` (`usage`) for a caller's own totals, `GET /admin/stats` for
+ * platform-wide ones. Ask for a count when you want a count; ask for a page
+ * when you want a page.
+ */
+interface ListOptions {
+    /** Maximum number of items to return in one page. */
+    limit?: number;
+    /** Opaque cursor from the previous page's response. */
+    cursor?: string;
+}
+/**
+ * Response for listing deployments
+ */
+interface DeploymentListResponse extends ListResponse {
+    /** Array of deployments */
+    deployments: Deployment[];
+}
+/**
+ * Acknowledgement of `DELETE /deployments/:deployment` — and the shape every
+ * mutation with no entity left to return follows.
+ *
+ * **The law:** a mutation answers with the resource it affected. If the
+ * resource still exists, that means the entity itself (`Deployment`,
+ * `Domain`, …). Otherwise it means this: the resource noun carrying the
+ * item's canonical key, plus the resource's own state field — and ONLY when
+ * the resource survived in a transitional state, as an async deletion's does.
+ * Where the resource is simply gone, the key alone is the whole answer
+ * ({@link DomainDeleteResponse}, {@link TokenDeleteResponse}).
+ *
+ * Put positively: **an acknowledgement is a projection of the resource** —
+ * its key, plus its own state field where the state changed. That is the
+ * test to apply, and it is sharper than "no constant", which this shape
+ * would fail on its own terms: `status` here is the literal `'deleting'` on
+ * every success, exactly as fixed as a `changed: true` would be.
+ *
+ * The difference is not how predictable the value is, it is what the field
+ * IS. `status` is the deployment's own field — the same one `GET
+ * /deployments/:deployment` returns — so this response is `Deployment`
+ * narrowed to two members, and a client renders it with the code it already
+ * has. `changed: true`, `queued: true` and `success: true` are not fields of
+ * any entity; they exist only to assert that the call worked, which the
+ * status code already said. Sync versus accepted is likewise the status
+ * code's job — 200 versus 202 — not a boolean's.
+ *
+ * No prose either (`message`): an acknowledgement is data, and each surface
+ * composes its own copy.
+ */
+interface DeploymentDeleteResponse {
+    /** The deployment hostname that was marked for removal */
+    readonly deployment: string;
+    /** The state the deployment is in while background cleanup runs */
+    readonly status: DeploymentStatusType;
+}
+/**
+ * Domain status constants
+ *
+ * - PENDING: DNS not configured
+ * - PARTIAL: DNS partially configured
+ * - SUCCESS: DNS fully verified
+ * - PAUSED: Domain paused due to plan enforcement (billing)
+ */
+declare const DomainStatus: {
+    readonly PENDING: "pending";
+    readonly PARTIAL: "partial";
+    readonly SUCCESS: "success";
+    readonly PAUSED: "paused";
+};
+type DomainStatusType = (typeof DomainStatus)[keyof typeof DomainStatus];
+/**
+ * Core domain object - used in both API responses and SDK
+ */
+interface Domain {
+    /** The domain name */
+    readonly domain: string;
+    /** Full URL to the domain (e.g., 'https://www.example.com') */
+    readonly url: string;
+    /** The deployment hostname this domain points to (null = domain added but not yet linked) */
+    deployment: string | null;
+    /** Current domain status */
+    status: DomainStatusType;
+    /** Labels for categorization and filtering (lowercase, alphanumeric with separators). Always present, empty array when none. */
+    labels: string[];
+    /** Unix timestamp (seconds) when domain was created */
+    readonly created: number;
+    /** Unix timestamp (seconds) when deployment was last linked, null if never linked */
+    linked: number | null;
+    /** Total deployment links */
+    links: number;
+}
+/**
+ * Return shape of `domains.set()` — `Domain` plus an SDK-derived flag indicating
+ * whether the underlying `PUT /domains/:name` created the record (HTTP 201) or
+ * updated an existing one (HTTP 200).
+ *
+ * `isCreate` is not part of the wire format — the API returns a plain `Domain`
+ * body. The SDK derives the flag from the HTTP status code so callers (notably
+ * the CLI) can format different output for the create vs repoint paths without
+ * a second round-trip.
+ */
+interface DomainSetResult extends Domain {
+    /** `true` when this call created a new domain; `false` when it updated an existing one. */
+    isCreate: boolean;
+}
+/**
+ * Response for listing domains
+ */
+interface DomainListResponse extends ListResponse {
+    /** Array of domains */
+    domains: Domain[];
+}
+/**
+ * Acknowledgement of `DELETE /domains/:domain`. The row is gone, so there is
+ * no state to state — the canonical domain name is the whole answer. See
+ * {@link DeploymentDeleteResponse} for the law.
+ */
+interface DomainDeleteResponse {
+    /** The domain name that was removed, normalized */
+    readonly domain: string;
+}
+/**
+ * Acknowledgement of `POST /domains/:domain/verify` (202). The DNS check is
+ * queued, not performed — the accepted status code says so, and the domain's
+ * own status is unchanged until the check runs, which is why none is stated
+ * here. See {@link DeploymentDeleteResponse} for the law.
+ */
+interface DomainVerifyResponse {
+    /** The domain whose DNS verification was queued, normalized */
+    readonly domain: string;
+}
+/**
+ * DNS record types supported for domain configuration
+ */
+type DnsRecordType = 'A' | 'CNAME';
+/**
+ * DNS record required for domain configuration
+ */
+interface DnsRecord {
+    /** Record type (A for apex, CNAME for subdomains) */
+    type: DnsRecordType;
+    /** The DNS name to configure */
+    name: string;
+    /** The value to set (IP for A, hostname for CNAME) */
+    value: string;
+}
+/**
+ * DNS provider information for a domain
+ */
+interface DnsProvider {
+    /** Provider name (e.g., "Cloudflare", "GoDaddy"), null if unknown */
+    name: string | null;
+}
+/**
+ * Response for domain DNS provider lookup
+ */
+/**
+ * What a DNS lookup found for a domain. An envelope rather than a bare
+ * {@link DnsProvider} because a lookup can succeed and learn more than the
+ * provider later; the shape is named so a consumer can hold one.
+ */
+interface DnsLookup {
+    /** The provider serving this domain's DNS, absent when unidentified */
+    provider?: DnsProvider;
+}
+/**
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface DomainDnsResponse {
+    /** The domain name */
+    domain: string;
+    /** DNS provider information, null if not yet looked up */
+    dns: DnsLookup | null;
+}
+/**
+ * Response for `GET /domains/:domain/share` — the domain plus the salted
+ * hash that lets someone else complete its DNS setup without an account.
+ *
+ * `/admin/domains/:domain/share` answers the same shape, which is the admin
+ * law working: the operator surface is the public grammar with a prefix.
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface DomainShareResponse {
+    /** The domain the setup link is for */
+    readonly domain: string;
+    /** The salted setup hash that authorizes the share */
+    readonly hash: string;
+}
+/**
+ * Response for domain DNS records
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface DomainRecordsResponse {
+    /** The domain name */
+    domain: string;
+    /** The apex (registered) domain where DNS records are managed */
+    apex: string;
+    /** Required DNS records for configuration */
+    records: DnsRecord[];
+}
+/**
+ * The envelope an `Idempotency-Key` must fit, and how long a replay lasts.
+ *
+ * Format lives here rather than on the server alone by the format-vs-policy
+ * rule: a client can decide offline whether a key is well-formed, and the
+ * API would reject the same value the same way.
+ */
+declare const IDEMPOTENCY_KEY_CONSTRAINTS: {
+    /**
+     * HTTP header name. Here for the same reason {@link CALLER.HEADER} is: a
+     * wire header has two ends, and the package that owns the value's format
+     * is the only place both ends can read its name from.
+     */
+    readonly HEADER: "Idempotency-Key";
+    readonly MAX_LENGTH: 256;
+    /** How long a stored 201 stays replayable. */
+    readonly WINDOW_SECONDS: number;
+};
+/**
+ * Normalize a `via` value from any transport — trimmed, lowercased, and a
+ * member of {@link DeploymentVia}, or `undefined`.
+ *
+ * A format rule by this package's own test: a client can decide offline
+ * whether a value is well-formed, and the API reaches the same verdict on the
+ * same input. It lived server-side until 2026-08-06, which meant clients could
+ * only learn their label was unusable by noticing analytics had gone quiet.
+ *
+ * **Not knowing your `via` is not an error** — an unrecognized value yields
+ * `undefined` rather than throwing, because origin tracking is telemetry and a
+ * deploy must never fail over it. A caller that has an honest default should
+ * prefer it (`normalizeVia(process.env.SHIP_VIA) ?? DeploymentVia.CLI`): the
+ * deploy really did come from the CLI, so recording that beats recording
+ * nothing.
+ */
+declare function normalizeVia(value: unknown): DeploymentViaType | undefined;
+/**
+ * Validate an idempotency key, returning the trimmed value or `undefined`
+ * when none was supplied. Throws {@link ShipError.validation} when the value
+ * cannot be sent — the same verdict the API would reach, reached earlier.
+ */
+declare function validateIdempotencyKey(value: unknown): string | undefined;
+/**
+ * Response for `GET /labels` — every label in use across the caller's
+ * deployments, domains and tokens, grouped and ordered by last use.
+ *
+ * The one plural noun outside the list contract, deliberately: labels have
+ * no identity, no row and no `created`, so there is nothing for a keyset
+ * cursor to resume after, and its consumer is an autocomplete that wants the
+ * whole set. Bounded by `PAGINATION.GLOBAL_LIMIT` rather than paginated.
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface LabelsResponse {
+    readonly labels: string[];
+}
+/**
+ * Response for `POST /setup` — the DNS instructions for one domain, written
+ * for a human to follow at their registrar.
+ *
+ * `custom` is the provider-specific walkthrough when the provider is known;
+ * `generic` always answers, so a caller never has nothing to show.
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface SetupInstructionsResponse {
+    /** The domain the instructions are for — a report names its subject */
+    readonly domain: string;
+    /** One-line summary of what to do */
+    readonly tldr: string;
+    /** Provider-specific instructions, null when the provider is unknown */
+    readonly custom: string | null;
+    /** Provider-agnostic instructions — always present */
+    readonly generic: string;
+    /** The identified DNS provider, null when unknown */
+    readonly provider: string | null;
+}
+/**
+ * `POST /domains/validate` — a report answering "is this name usable, and if
+ * not, why".
+ *
+ * An unusable name is a legitimate ANSWER, not a failure, so this is a 200 and
+ * the verdict rides the body. `reason` was named `error` until 2026-07-29,
+ * which collided with {@link ErrorResponse}'s reserved key — there `error` is
+ * an `ErrorType` a client branches on, here it is prose a client displays, and
+ * one key cannot mean both. See {@link DeploymentDeleteResponse} for the law.
+ */
+interface DomainValidateResponse {
+    /** Whether the domain is valid */
+    valid: boolean;
+    /** Normalized domain name, null when invalid */
+    normalized: string | null;
+    /** Whether the domain is available, null when invalid */
+    available: boolean | null;
+    /** Why the name is unusable, null when valid — displayed verbatim. */
+    reason: string | null;
+}
+/**
+ * Core deploy token object - used in both API responses and SDK.
+ *
+ * The secret is never here: it is shown once at creation
+ * ({@link TokenCreateResponse.secret}) and never again, so an entity read
+ * carries only the management identifier and lifecycle metadata.
+ */
+interface Token {
+    /** 7-char management identifier (e.g., "a1b2c3d") */
+    readonly token: string;
+    /** Labels for categorization and filtering. Always present, empty array when none. */
+    labels: string[];
+    /** Unix timestamp (seconds) when token was created */
+    readonly created: number;
+    /** Unix timestamp (seconds) when token expires, null for never */
+    readonly expires: number | null;
+    /** Unix timestamp (seconds) of the last request authenticated with this token, null if never used */
+    readonly used: number | null;
+}
+/**
+ * Response for listing tokens
+ */
+interface TokenListResponse extends ListResponse {
+    /** Array of tokens (the secret is never among them) */
+    tokens: Token[];
+}
+/**
+ * Response from token creation. Extends Token with the one field that
+ * exists only on creation — the same shape as
+ * {@link DeploymentCreateResponse}, because a 201 returns the resource it
+ * created plus whatever is knowable only once.
+ */
+interface TokenCreateResponse extends Token {
+    /** The raw credential value (shown once at creation, then never again) */
+    readonly secret: string;
+}
+/**
+ * Acknowledgement of `DELETE /tokens/:token`. The credential is revoked and
+ * its row is gone, so the management identifier is the whole answer. See
+ * {@link DeploymentDeleteResponse} for the law.
+ */
+interface TokenDeleteResponse {
+    /** The 7-char management identifier that was revoked */
+    readonly token: string;
+}
+/**
+ * Account plan constants
+ */
+declare const AccountPlan: {
+    readonly FREE: "free";
+    readonly STANDARD: "standard";
+    readonly SPONSORED: "sponsored";
+    readonly ENTERPRISE: "enterprise";
+    readonly SUSPENDED: "suspended";
+    readonly TERMINATING: "terminating";
+    readonly TERMINATED: "terminated";
+};
+type AccountPlanType = (typeof AccountPlan)[keyof typeof AccountPlan];
+/**
+ * Account usage metrics — always available regardless of billing provider.
+ *
+ * This is where a caller's own totals live. Lists answer pages and carry no
+ * `total` (see {@link ListOptions}); a count is an aggregate over a
+ * collection, so it belongs to the summary resource that owns the
+ * collection. `GET /account` is that resource for one caller, `GET
+ * /admin/stats` for the platform.
+ *
+ * The counted dimensions are the ones the plan caps — deployments and
+ * domains (`PlatformLimits`) — plus the billable custom-domain subset, so a
+ * surface can render "3 of 10" without a second request.
+ */
+interface AccountUsage {
+    /** Number of active custom domains (excludes paused) */
+    customDomains: number;
+    /**
+     * Deployments counted against the plan's deployment cap — every row
+     * whatever its status, because that is what the cap counts, so a surface
+     * renders "3 of 10" against the denominator the 403 divides by. (`GET
+     * /deployments` lists successful ones only; that is a different question
+     * asked of a different resource.) Optional by the additive-evolution law:
+     * an API predating this field omits it.
+     */
+    deployments?: number;
+    /**
+     * Domains counted against the plan's domain cap — every domain, platform
+     * and custom alike, unlike `customDomains`. Optional for the same reason.
+     */
+    domains?: number;
+}
+/**
+ * Core account object - used in both API responses and SDK
+ * All fields are readonly to prevent accidental mutations
+ */
+interface Account {
+    /** User email address */
+    readonly email: string;
+    /** User display name, null if not set */
+    readonly name: string | null;
+    /** User profile picture URL, null if not set */
+    readonly picture: string | null;
+    /** Account plan status */
+    readonly plan: AccountPlanType;
+    /** Account usage metrics (custom domains, etc.) */
+    readonly usage: AccountUsage;
+    /** Unix timestamp (seconds) when account was created */
+    readonly created: number;
+    /** Unix timestamp (seconds) when account was activated (first deployment), null if not yet activated */
+    readonly activated: number | null;
+    /** Last 4 characters of the API key for identification, null when no key generated */
+    readonly hint: string | null;
+    /**
+     * Unix timestamp (seconds) of the API key's last use, null when never
+     * used or no key generated. Optional on the type by the additive-evolution
+     * law: published SDK versions may predate the field, so consumers read it
+     * when present rather than forcing a lockstep SDK release.
+     */
+    readonly used?: number | null;
+    /** Grace period expiration (unix seconds), null if no grace period active */
+    readonly grace: number | null;
+}
+/**
+ * Account as returned by `GET /account` — the entity plus how the request
+ * was authorized, so `whoami` can answer "what credential am I holding?".
+ * Request-scoped fields live on the response type, never on the entity
+ * (the `DeploymentCreateResponse` pattern).
+ */
+interface AccountGetResponse extends Account {
+    /** How the request that produced this response was authorized. */
+    readonly authMethod: AuthMethodType;
+    /** Present (and true) only when the caller is an operator acting as themselves. */
+    readonly isAdmin?: true;
+    /** Present only during read-only admin impersonation: the operator's account id. */
+    readonly impersonatedBy?: string;
+}
+/**
+ * Acknowledgement of `DELETE /account` (202). Termination is asynchronous —
+ * a cleanup consumer finishes the job — so the account survives long enough
+ * to state the plan it is transitioning through. `plan` is the account's
+ * state field, the way `status` is a deployment's. See
+ * {@link DeploymentDeleteResponse} for the law.
+ */
+interface AccountDeleteResponse {
+    /** The account that was marked for termination */
+    readonly account: string;
+    /** The plan the account is in while cleanup runs */
+    readonly plan: AccountPlanType;
+}
+/**
+ * Response from `PUT /account/key` — the account's single API key, minted in
+ * place of whatever was there before.
+ *
+ * There is no entity to return: only the key's last-4 `hint` is durable
+ * (`Account.hint`), and the plaintext exists exactly once, in this response.
+ * The raw credential is `secret` on every surface that mints one — the same
+ * field `TokenCreateResponse` carries — because one concept gets one name.
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface AccountKeyResponse {
+    /** The raw API key (shown once at mint, then never again) */
+    readonly secret: string;
+}
+/**
+ * Account-specific configuration overrides
+ * Allows per-account customization of limits without changing plan
+ */
+interface AccountOverrides {
+    /** Override for maximum number of domains */
+    domains?: number;
+    /** Override for maximum number of deployments */
+    deployments?: number;
+    /** Override for maximum individual file size in bytes */
+    fileSize?: number;
+    /** Override for maximum number of files per deployment */
+    filesCount?: number;
+    /** Override for maximum total deployment size in bytes */
+    totalSize?: number;
+}
+/**
+ * Every path the public API answers on, declared once.
+ *
+ * The URL surface was written out in four places — the API's mounts, the
+ * SDK's client, the dashboard's client, and the post-deploy smoke — so a
+ * rename meant finding all four. The first three now read this table.
+ *
+ * The smoke (`cloudflare/api/smoke.mjs`) deliberately still spells its own:
+ * five of its nine paths are `/admin/*`, which this table excludes by
+ * design, and splitting one list between a registry and literals reads worse
+ * than keeping it uniform.
+ *
+ * **What this guarantees, exactly.** Collection paths are mounted from here,
+ * so producer and consumer cannot diverge. Item paths are declared here and
+ * consumed by clients, but the API spells them relative to their mount
+ * (`/:deployment/config`), so the table does not *generate* them — it is
+ * held to them by `api/tests/architecture/api-paths.test.ts`, which fails if
+ * any entry names a path no route answers. Some entries have no client yet
+ * (`DEPLOYMENT_CONFIG`, `DOMAIN_PROPAGATION` — endpoints the SDK
+ * deliberately does not reach); the fence is what keeps those honest rather
+ * than merely asserted.
+ *
+ * **The operator surface is deliberately absent.** `/admin/*` paths belong
+ * to `web/my`, for the same reason its row types do: this package is
+ * published, and the operator surface is not public (see `CLAUDE.md`, "Admin
+ * types"). A path here is a promise to every npm consumer; `/admin` is a
+ * promise to one dashboard.
+ *
+ * Item paths are functions rather than templates so the key is interpolated
+ * in one place, encoded the same way by every caller.
+ */
+declare const API_PATHS: {
+    readonly DEPLOYMENTS: "/deployments";
+    readonly DEPLOYMENT: (deployment: string) => string;
+    readonly DEPLOYMENT_CONFIG: (deployment: string) => string;
+    readonly DOMAINS: "/domains";
+    readonly DOMAIN: (domain: string) => string;
+    readonly DOMAIN_VERIFY: (domain: string) => string;
+    readonly DOMAIN_DNS: (domain: string) => string;
+    readonly DOMAIN_RECORDS: (domain: string) => string;
+    readonly DOMAIN_SHARE: (domain: string) => string;
+    readonly DOMAIN_PROPAGATION: (domain: string) => string;
+    readonly DOMAINS_VALIDATE: "/domains/validate";
+    readonly TOKENS: "/tokens";
+    readonly TOKEN: (token: string) => string;
+    readonly ACCOUNT: "/account";
+    readonly ACCOUNT_KEY: "/account/key";
+    readonly ACCOUNT_CLAIM: "/account/claim";
+    readonly ACTIVITIES: "/activities";
+    readonly LABELS: "/labels";
+    readonly LIMITS: "/limits";
+    readonly PING: "/ping";
+    readonly SETUP: "/setup";
+    readonly SPA_CHECK: "/spa-check";
+    readonly UPLOAD: "/upload";
+};
+/**
+ * The deploy request's multipart field names — the other half of the wire
+ * surface beside {@link API_PATHS}. `POST /deployments` (and the first-party
+ * `/upload`) is multipart/form-data, and these are the names the API reads.
+ *
+ * Declared once because the body has three independent WRITERS — the SDK's
+ * Node and browser body builders, and the n8n community node's hand-rolled
+ * client (which cannot import this under n8n Cloud's zero-dependency rule,
+ * and fences its restated copy instead) — and until this export every writer
+ * restated the strings the API parses, with nothing comparing them.
+ *
+ * `FILES` carries one entry per file (the API reads it with `getAll`); every
+ * other field is single. The `@internal` flags are serialized as the literal
+ * string `'true'` and belong to first-party surfaces only.
+ */
+declare const DEPLOY_FIELDS: {
+    /** One entry per file — read with `getAll`. */
+    readonly FILES: "files[]";
+    /** JSON array of MD5 hex digests, index-aligned with `FILES`. */
+    readonly CHECKSUMS: "checksums";
+    /** JSON array of label strings. */
+    readonly LABELS: "labels";
+    /** The deploying surface's {@link DeploymentVia} member. */
+    readonly VIA: "via";
+    /** Plaintext password — the API hashes it server-side. */
+    readonly PASSWORD: "password";
+    /** @internal Server-processing flag — first-party `/upload` only. */
+    readonly BUILD: "build";
+    /** @internal Server-processing flag — first-party `/upload` only. */
+    readonly PRERENDER: "prerender";
+    /** @internal Server-processing flag — first-party `/upload` only. */
+    readonly SPA: "spa";
+    /** @internal reCAPTCHA proof — `web/www`'s public uploader only. */
+    readonly CAPTCHA: "captcha";
+};
+/**
+ * All possible error types in the ShipStatic platform.
+ *
+ * Developer-friendly key names map to stable wire-format string values.
+ * Both the value and the type are exported under the same name so callers
+ * can use `ErrorType.Validation` (value comparison) and `: ErrorType` (type
+ * annotation) without ceremony — matching the pattern other status objects
+ * (`DeploymentStatus`, `DomainStatus`, `AccountPlan`, `AuthMethod`) follow.
+ */
+declare const ErrorType: {
+    /**
+     * Validation failed. Input shape is wrong.
+     *
+     * Carries 400 when an API judged it — including a client-side pre-check of a
+     * rule the server enforces too, which keeps the error identical wherever it
+     * was caught. **Statusless** when a client rejects something no API judges,
+     * such as a CLI's own command grammar: `status` is documented "(API
+     * contexts)" on `ErrorResponse`, so there is none to report.
+     */
+    readonly Validation: "validation_failed";
+    /** Resource not found (404). */
+    readonly NotFound: "not_found";
+    /** Authenticated but not allowed (403). User lacks permission for this action. */
+    readonly Forbidden: "forbidden";
+    /** Rate limit exceeded (429). */
+    readonly RateLimit: "rate_limit_exceeded";
+    /** Authentication required or failed (401). Missing/invalid credentials. */
+    readonly Authentication: "authentication_failed";
+    /** Business rule violation. Catch-all for 4xx state-rule errors that aren't more specific. */
+    readonly Business: "business_logic_error";
+    /** API server error (500). Generic server-side fault. */
+    readonly Api: "internal_server_error";
+    /** Network/connection error. Client-side only — set by HTTP clients on fetch failure; never produced server-side. */
+    readonly Network: "network_error";
+    /** Operation was cancelled. Client-side only — set on `AbortSignal` abort; never produced server-side. */
+    readonly Cancelled: "operation_cancelled";
+    /** File operation error. Client-side only — set by SDK during local file processing; never produced server-side. */
+    readonly File: "file_error";
+    /** Configuration error. Client-side only — set by SDK during config parsing/validation; never produced server-side. */
+    readonly Config: "config_error";
+};
+type ErrorType = (typeof ErrorType)[keyof typeof ErrorType];
+/**
+ * Standard error response format used everywhere
+ */
+interface ErrorResponse {
+    /** Error type identifier */
+    error: ErrorType;
+    /** Human-readable error message */
+    message: string;
+    /** HTTP status code (API contexts) */
+    status?: number;
+    /** Optional additional error details. Untyped by design — narrow at the read site. */
+    details?: unknown;
+}
+/**
+ * Simple unified error class for both API and SDK
+ */
+declare class ShipError extends Error {
+    readonly type: ErrorType;
+    readonly status?: number | undefined;
+    readonly details?: unknown | undefined;
+    constructor(type: ErrorType, message: string, status?: number | undefined, details?: unknown | undefined);
+    /** Convert to wire format */
+    toResponse(): ErrorResponse;
+    /**
+     * Construct a `ShipError` from an HTTP error response.
+     *
+     * Best-effort body parse for `{ message, error?, details? }`. Message
+     * resolution: `body.message` → `body.error` → `"<operationName> failed with
+     * status <N>"`.
+     *
+     * Type resolution: trusts `body.error` when it's a known server-producible
+     * `ErrorType` (preserves the wire's intent — server's
+     * `ShipError.validation(...)` round-trips back to `ErrorType.Validation`
+     * on the client). Falls back to status-derived (401 → Authentication,
+     * 403 → Forbidden, 429 → RateLimit, else → Api) for non-API responses
+     * (CDN errors, intermediaries) or malformed bodies. Client-only types
+     * (`Network`, `Cancelled`, `File`, `Config`) are filtered out of the
+     * trusted set — a misbehaving server claiming one of those is ignored.
+     *
+     * `operationName` (e.g. `"Get account"`) is used to compose the fallback
+     * message. Defaults to `"Request"`. Same convention as `fromFetchError`.
+     *
+     * Async because it reads the response body. Returns rather than throws so
+     * callers can compose; most will `throw await ShipError.fromHttpResponse(...)`.
+     */
+    static fromHttpResponse(response: Response, operationName?: string): Promise<ShipError>;
+    /**
+     * Construct a `ShipError` from an error caught around a `fetch()` call.
+     *
+     * The mirror of `fromHttpResponse` for the *other* side of the HTTP error
+     * story — the network layer failing (offline, CORS, abort) rather than the
+     * server returning a non-OK response.
+     *
+     * Routing:
+     * - Already a `ShipError` → returned as-is (caller's intent preserved)
+     * - `AbortError` → `ShipError.cancelled(...)`
+     * - A transport failure → `ShipError.network(...)` — see `isTransportFailure`
+     *   for what each runtime offers as evidence
+     * - Any other `Error` → `ShipError(Api, ...)` (no HTTP status — fetch never reached the server)
+     * - Anything else (string, undefined, etc.) → `ShipError(Api, ...)`
+     *
+     * The optional `operationName` is composed into the message for context:
+     * `"Get account was cancelled"`, `"Get account failed: ..."`. Defaults to
+     * `"Request"` when omitted.
+     */
+    static fromFetchError(cause: unknown, operationName?: string): ShipError;
+    static validation(message: string, details?: unknown): ShipError;
+    static notFound(resource: string, id?: string): ShipError;
+    static forbidden(message: string, details?: unknown): ShipError;
+    static rateLimit(message?: string, details?: unknown): ShipError;
+    /**
+     * Construct an Authentication (401) error.
+     *
+     * **Telemetry pattern — `details: { internal: '<tag>' }`.** When the
+     * server creates an auth error with an `internal` key in `details`
+     * (e.g. `{ internal: 'session_invalid' }`), `toResponse()` strips the
+     * entire `details` object before serialization. This keeps the wire
+     * response a clean "Authentication failed" while preserving granular
+     * server-side telemetry (which strategy/check failed) for logs and tests.
+     *
+     * Use this pattern in API auth code; do not put client-visible info under
+     * `internal`. Other `details` keys round-trip normally.
+     */
+    static authentication(message?: string, details?: unknown): ShipError;
+    static business(message: string, status?: number, details?: unknown): ShipError;
+    static network(message: string, details?: unknown): ShipError;
+    static cancelled(message: string, details?: unknown): ShipError;
+    static file(message: string, details?: unknown): ShipError;
+    static config(message: string, details?: unknown): ShipError;
+    static api(message: string, status?: number, details?: unknown): ShipError;
+    /**
+     * The caller is at fault — by HTTP's own definition of a 4xx, or by a type
+     * that is client-attributable without ever having a status (`Config`,
+     * `File`, raised locally by the SDK).
+     *
+     * Both arms are load-bearing, because type and status are independent
+     * axes. `fromHttpResponse` trusts `body.error` only when it names a
+     * server-producible type; a non-OK response without one is status-derived,
+     * so a CDN 404 or any intermediary error arrives as `Api` — a server-fault
+     * *type* carrying a client *status*. Judging by type alone would report it
+     * as a platform failure and bury the server's own message.
+     */
+    isClientError(): boolean;
+    isNetworkError(): boolean;
+    isAuthError(): boolean;
+    isType(errorType: ErrorType): boolean;
+}
+/**
+ * Type guard to check if an unknown value is a ShipError.
+ *
+ * Uses structural checking instead of instanceof to handle module duplication
+ * in bundled applications where multiple copies of the ShipError class may exist.
+ *
+ * @example
+ * if (isShipError(error)) {
+ *   console.log(error.status, error.message);
+ * }
+ */
+declare function isShipError(error: unknown): error is ShipError;
+/**
+ * Plan-based platform limits returned by the `/limits` endpoint.
+ *
+ * The SDK fetches these once on first API call to drive client-side
+ * file-size / file-count / total-size validation that mirrors what the API
+ * would enforce server-side. Limits vary by account plan.
+ *
+ * These are the *platform's* posted caps for the current account — server
+ * truth delivered at runtime, never hard-coded on the client.
+ *
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface PlatformLimits {
+    /** Maximum size in bytes for a single file. */
+    maxFileSize: number;
+    /** Maximum number of files in a single deployment. */
+    maxFilesCount: number;
+    /** Maximum total size in bytes across all files in a deployment. */
+    maxTotalSize: number;
+}
+/**
+ * Blocked file extensions — files that cannot be uploaded.
+ *
+ * We accept any file type by default and derive Content-Type from the
+ * extension at serve time (via mime-db in the API worker). Unknown extensions
+ * are served as `application/octet-stream` with `X-Content-Type-Options: nosniff`.
+ *
+ * The blocklist targets file types that pose direct security risks when hosted:
+ * executables, disk images, malware vectors, dangerous scripts, and shortcuts.
+ */
+declare const BLOCKED_EXTENSIONS: ReadonlySet<string>;
+/**
+ * Check if a filename has a blocked extension.
+ * Extracts the extension from the filename and checks against the blocklist.
+ * Case-insensitive. Returns false for files without extensions.
+ *
+ * @example
+ * isBlockedExtension('virus.exe')     // true
+ * isBlockedExtension('app.dmg')       // true
+ * isBlockedExtension('style.css')     // false
+ * isBlockedExtension('data.custom')   // false
+ * isBlockedExtension('README')        // false
+ */
+declare function isBlockedExtension(filename: string): boolean;
+/**
+ * The `accept` attribute value for a browser file picker offering web files.
+ *
+ * **This is a hint, never a rule.** `BLOCKED_EXTENSIONS` is the platform's
+ * gate and the only thing that decides what may be hosted; this constant
+ * decides what a *file dialog* shows first. The two are not two halves of one
+ * policy, and this one must never be consulted to accept or reject a file.
+ *
+ * The distinction is structural, not stylistic. `accept` can express only an
+ * allowlist, while the platform's rule is a blocklist — so this list is
+ * necessarily *narrower* than what the platform hosts, and reading it as
+ * authority would reject files the platform serves happily. It is also not
+ * enforcement in the browser's own terms: every file dialog offers an
+ * all-files escape, and **drag-and-drop ignores `accept` entirely**. The
+ * dropzone and the picker must reach the same verdict on the same files, and
+ * they do — because the verdict is `validateFiles`, downstream of both.
+ *
+ * Kept beside `BLOCKED_EXTENSIONS` so one file holds both, which is what lets
+ * `tests/validation-constants.test.ts` fence the invariant that matters: the
+ * picker must never offer a file the platform will refuse.
+ */
+declare const WEB_FILE_ACCEPT: string;
+/**
+ * Characters that are unsafe in filenames for static hosting.
+ *
+ * Blocks only characters that genuinely break the upload→serve round-trip:
+ * - # ? %        URL round-trip breakers (fragment, query, encoding ambiguity)
+ * - \            Path separator confusion (upload splits on backslash)
+ * - < > "        XSS vectors with zero legitimate use in filenames
+ * - \x00-\x1f \x7f  Control characters (header injection, display corruption)
+ *
+ * Everything else is allowed — browser percent-encodes, Worker decodes, R2 matches.
+ */
+declare const UNSAFE_FILENAME_CHARS: RegExp;
+/**
+ * Check if a filename contains unsafe characters.
+ *
+ * @example
+ * hasUnsafeChars('saved_resource(1).html')  // false — parentheses are safe
+ * hasUnsafeChars('page[slug].js')           // false — brackets are safe
+ * hasUnsafeChars('file#anchor.html')        // true  — # breaks URL resolution
+ * hasUnsafeChars('file<tag>.html')          // true  — < is an XSS vector
+ */
+declare function hasUnsafeChars(filename: string): boolean;
+/**
+ * Path segment names that indicate an unbuilt project was uploaded instead of build output.
+ * Used for early detection in CLI, browser, and server validation.
+ */
+declare const UNBUILT_PROJECT_MARKERS: ReadonlySet<string>;
+/**
+ * Check if a file path contains an unbuilt project marker.
+ *
+ * @example
+ * hasUnbuiltMarker('node_modules/react/index.js')  // true
+ * hasUnbuiltMarker('package.json')                  // true
+ * hasUnbuiltMarker('dist/index.html')               // false
+ */
+declare function hasUnbuiltMarker(filePath: string): boolean;
+/**
+ * `GET /ping` — a report of the server clock.
+ *
+ * Liveness is the STATUS CODE's answer, not a field's: a 200 means reachable,
+ * and any other outcome throws before a body is read. So the body carries the
+ * one thing a status code cannot — the server's own clock, which is what lets a
+ * client detect skew against a token expiry. It read `{ success: true,
+ * timestamp? }` until 2026-07-29, where `success` was a literal constant in the
+ * route (zero bits, and the platform's own named anti-pattern) while the field
+ * that IS the payload was optional. See {@link DeploymentDeleteResponse} for
+ * the law, and `tests/response-shapes.test.ts` for the fence that holds it.
+ */
+interface PingResponse {
+    /** Server time in unix seconds — the one wire unit for timestamps. */
+    readonly timestamp: number;
+}
+/**
+ * Where human identity is mounted on the API host. The API mounts Better
+ * Auth at this path (sign-in, sign-out, session reads, admin impersonation)
+ * and the web console's auth client posts to it — shared here so the two
+ * halves of the auth pair agree by construction, the same way both sides
+ * already share the credential prefixes below.
+ */
+declare const AUTH_BASE_PATH = "/auth";
+/**
+ * How a request (or recorded activity) was authorized.
+ *
+ * Client populations: `SESSION` (first-party cookie), `API_KEY` (`ship-`
+ * key), `TOKEN` (`deploy-` deploy token), `AGENT` (anonymous public deploy —
+ * no credential; the platform grants the public-account identity per
+ * request), `OAUTH` (delegated access token). Server populations: `WEBHOOK`
+ * (signed webhook processing), `SYSTEM` (scheduled/background jobs).
+ */
+declare const AuthMethod: {
+    readonly SESSION: "session";
+    readonly API_KEY: "apiKey";
+    readonly TOKEN: "token";
+    readonly AGENT: "agent";
+    readonly OAUTH: "oauth";
+    readonly WEBHOOK: "webhook";
+    readonly SYSTEM: "system";
+};
+type AuthMethodType = (typeof AuthMethod)[keyof typeof AuthMethod];
+/**
+ * Shape constants for API keys (`ship-{64 hex chars}`).
+ * Single source of truth used by validation utilities and auth middleware.
+ */
+declare const API_KEY: {
+    /** Prefix that identifies an API key. */
+    readonly PREFIX: "ship-";
+    /** Number of hex characters following the prefix. */
+    readonly HEX_LENGTH: 64;
+    /** Total length of an API key including prefix (`PREFIX.length + HEX_LENGTH = 69`). */
+    readonly TOTAL_LENGTH: 69;
+    /** Number of trailing characters used to display a redacted hint (e.g. last 4). */
+    readonly HINT_LENGTH: 4;
+};
+/**
+ * Shape constants for deploy tokens (`deploy-{64 hex chars}`).
+ * Single source of truth used by validation utilities and auth middleware.
+ */
+declare const DEPLOY_TOKEN: {
+    /** Prefix that identifies a deploy token. */
+    readonly PREFIX: "deploy-";
+    /** Number of hex characters following the prefix. */
+    readonly HEX_LENGTH: 64;
+    /** Total length of a deploy token including prefix (`PREFIX.length + HEX_LENGTH = 71`). */
+    readonly TOTAL_LENGTH: 71;
+};
+/**
+ * Shape constants for caller identifiers (the `X-Caller` instance-identity
+ * header — rate-limit bucketing for multi-tenant orchestrators). The API
+ * normalizes case and silently ignores malformed values (the header is
+ * unauthenticated); clients validate at the boundary via `validateCaller`,
+ * so a value the server would drop fails fast instead.
+ */
+declare const CALLER: {
+    /** HTTP header name. */
+    readonly HEADER: "X-Caller";
+    /** Maximum identifier length. */
+    readonly MAX_LENGTH: 128;
+    /** Allowed characters: alphanumeric, dot, underscore, hyphen. */
+    readonly PATTERN: RegExp;
+};
+/**
+ * Token populations distinguishable by shape. The platform carries every
+ * client token in one wire slot (`Authorization: Bearer <value>`) and
+ * classifies by value, never by a side channel — this is the classifier.
+ *
+ * `API_KEY` and `DEPLOY_TOKEN` *are* `AuthMethod.API_KEY` and
+ * `AuthMethod.TOKEN` — the equality is structural, so a classification flows
+ * straight into an auth method and the pair can never drift. `OPAQUE` is any
+ * other value — shape says nothing about it, so only a lookup can. Today the
+ * server refuses every opaque bearer; the OAuth access-token population
+ * resolves there when the authorization server ships.
+ */
+declare const TokenKind: {
+    readonly API_KEY: "apiKey";
+    readonly DEPLOY_TOKEN: "token";
+    readonly OPAQUE: "opaque";
+};
+type TokenKindType = (typeof TokenKind)[keyof typeof TokenKind];
+/**
+ * Classify a client token by shape. The single dispatch used by both sides
+ * of the wire: API auth middleware (which population is this credential?)
+ * and SDK validation (which format rules apply before sending?). Sharing it
+ * is what guarantees client and server can never disagree on dispatch.
+ */
+declare function classifyToken(token: string): TokenKindType;
+/**
+ * OAuth scope vocabulary for delegated third-party access tokens.
+ * Single source of truth used by the authorization server (advertised in
+ * `scopes_supported`), the API's scope-enforcement middleware, and consent UI
+ * copy. The standard `offline_access` scope (refresh tokens) is not platform
+ * vocabulary and is deliberately absent — the middleware never checks it.
+ *
+ * Deliberately absent by design: any `tokens:*` scope, `account:write`, or
+ * admin scope — a delegated app must never mint credentials, delete the
+ * account, or act as admin.
+ */
+declare const OAuthScope: {
+    readonly ACCOUNT_READ: "account:read";
+    readonly DEPLOYMENTS_READ: "deployments:read";
+    readonly DEPLOYMENTS_WRITE: "deployments:write";
+    readonly DOMAINS_READ: "domains:read";
+    readonly DOMAINS_WRITE: "domains:write";
+};
+type OAuthScopeType = (typeof OAuthScope)[keyof typeof OAuthScope];
+declare const DEPLOYMENT_CONFIG_FILENAME = "ship.json";
+/** Default ship.json config for SPA routing. Single source of truth — used by both API and SDK. */
+declare const SPA_DEFAULT_CONFIG: {
+    readonly rewrites: readonly [{
+        readonly source: "/(.*)";
+        readonly destination: "/index.html";
+    }];
+};
+/**
+ * The `/spa-check` pre-flight's client-side envelope: which file is the
+ * check's subject, and how large it may be before a client skips the call.
+ *
+ * One fact with three holders until this export — the API's config declared
+ * the cap, the SDK's `checkSPA` hardcoded `100 * 1024`, and prose restated
+ * "100KB". `INDEX_FILE` is the selection rule (the file whose content rides
+ * `SPACheckRequest.index`), restated by every client that builds the request.
+ *
+ * Neither member is a validation boundary: a client over the cap simply
+ * skips the pre-flight, because the server answers an oversized index
+ * `isSPA: false` anyway. A consumer that cannot import this (n8n) needs no
+ * size copy at all — outcome parity is the server's, not the client's.
+ */
+declare const SPA_CHECK_CONSTRAINTS: {
+    /** The file whose content is the check's subject. */
+    readonly INDEX_FILE: "index.html";
+    /** Skip the pre-flight above this size — the server would answer false. */
+    readonly MAX_INDEX_BYTES: number;
+};
+/**
+ * Assert that a ship.json file is *syntactically* loadable. Syntax only —
+ * never schema.
+ *
+ * ship.json is validated and compiled on the server, deliberately: the schema
+ * and the compiler evolve, and a client that judged them would reject configs
+ * a newer platform accepts. That reasoning bounds what a client may check to
+ * the properties which are true of *every* past and future schema:
+ *
+ *   1. it parses as JSON — JSON syntax is frozen (RFC 8259), so text that
+ *      does not parse can never be a valid config;
+ *   2. its top level is an object — ship.json is `{ ... }` in every version.
+ *
+ * Both are monotonic: neither can ever reject something the server would
+ * accept. Everything beyond them (field names, types, rule semantics, which
+ * keys are permitted) stays server-side, where it can change.
+ *
+ * The payoff is the common case. Hand-edited JSON fails on a trailing comma,
+ * a `//` comment, single quotes, unquoted keys, or smart quotes pasted from
+ * documentation — mistakes that otherwise cost a full upload round-trip to
+ * discover. A UTF-8 BOM (Windows editors, PowerShell redirects) is stripped
+ * before parsing rather than rejected, because the server accepts it too;
+ * diverging there would reintroduce exactly the false rejection this
+ * function exists to avoid.
+ *
+ * @throws {ShipError} `ErrorType.Config` — the same type the server's own
+ * config rejection carries, so the error contract is identical wherever the
+ * failure is detected.
+ */
+declare function assertShipJsonSyntax(text: string): void;
+/**
+ * Validate API key format
+ */
+declare function validateApiKey(apiKey: string): void;
+/**
+ * Validate deploy token format
+ */
+declare function validateDeployToken(deployToken: string): void;
+/**
+ * Validate a client token of any population. Classifies by shape and applies
+ * the matching format rules: `ship-` keys and `deploy-` deploy tokens are
+ * validated strictly; opaque tokens (OAuth access tokens, future populations)
+ * only need to be non-empty — their validity is the server's to decide.
+ */
+declare function validateToken(token: string): void;
+/**
+ * Validate a caller identifier against the `CALLER` shape. The server
+ * silently ignores malformed values (the header is unauthenticated); clients
+ * call this at configuration time so the drop never silently happens.
+ */
+declare function validateCaller(caller: string): void;
+/**
+ * Validate API URL format
+ */
+declare function validateApiUrl(apiUrl: string): void;
+/**
+ * Check if a string matches the deployment identifier pattern (word-word-alphanumeric7).
+ * Example: "happy-cat-abc1234.shipstatic.com"
+ */
+declare function isDeployment(input: string): boolean;
+/**
+ * Request payload for SPA check endpoint
+ */
+interface SPACheckRequest {
+    /** Array of file paths */
+    files: string[];
+    /** HTML content of index.html file */
+    index: string;
+}
+/**
+ * Response from SPA check endpoint
+ */
+/**
+ * Which of the classifier's tiers reached the verdict, and why. Named rather
+ * than inline so the API's own `checkSPA` can return `SPACheckResponse`
+ * instead of restating its shape.
+ */
+interface SPACheckDebug {
+    /** Which tier made the detection */
+    tier: 'exclusions' | 'inclusions' | 'scoring' | 'ai' | 'fallback';
+    /** The reason for the detection result */
+    reason: string;
+}
+/**
+ * A report: it answers a question and carries only the answer (`CLAUDE.md`,
+ * "A report answers a question").
+ */
+interface SPACheckResponse {
+    /** Whether the project is detected as a Single Page Application */
+    isSPA: boolean;
+    /** Debugging information about detection */
+    debug: SPACheckDebug;
+}
+/**
+ * Represents a file that has been processed and is ready for deploy.
+ * Used across the platform (API, SDK, CLI) for file operations.
+ */
+interface StaticFile {
+    /**
+     * The content of the file.
+     * In Node.js, this is typically a `Buffer`.
+     * In the browser, this is typically a `File` or `Blob` object.
+     */
+    content: File | Buffer | Blob;
+    /**
+     * The desired path for the file on the server, relative to the deployment root.
+     * Should include the filename, e.g., `images/photo.jpg`.
+     */
+    path: string;
+    /**
+     * The original absolute file system path (primarily used in Node.js environments).
+     * This helps in debugging or associating the server path back to its source.
+     */
+    filePath?: string;
+    /**
+     * The MD5 hash (checksum) of the file's content.
+     * This is calculated by the SDK before deploy if not provided.
+     */
+    md5?: string;
+    /** The size of the file in bytes. */
+    size: number;
+}
+/** Default API URL if not otherwise configured. */
+declare const DEFAULT_API = "https://api.shipstatic.com";
+/**
+ * The Node SDK's ambient configuration pair — the ONLY environment variables
+ * the SDK reads, and therefore the COMPLETE list an embedding host must
+ * scrub (per `npm/ship`'s strict-isolation contract, scrubbing is the host's
+ * job, not the SDK's). A host that derives its scrub from this object's
+ * values — as the VS Code extension's child-process env block does — picks
+ * up a grown contract at the next pin bump instead of by remembered prose.
+ *
+ * Browser builds read no environment at all, and the CLI-only variables
+ * (`SHIP_PASSWORD`, `SHIP_VIA`) are deliberately NOT here: they are the
+ * CLI's operational levers, not the SDK's ambient contract — see
+ * `npm/ship/CLAUDE.md`, "CLI-only env vars".
+ */
+declare const SHIP_ENV: {
+    /** The one credential slot — any platform token. */
+    readonly TOKEN: "SHIP_TOKEN";
+    /** The API endpoint override. */
+    readonly API_URL: "SHIP_API_URL";
+};
+/**
+ * Where a human creates an API key — the console deep link quoted by every
+ * surface that teaches authentication (the CLI's config wizard, the VS Code
+ * and n8n listings, the n8n rate-limit hint and credential copy). Written
+ * out in five files across three repos until this export.
+ *
+ * Production-branded by design: published artifacts name the product, never
+ * an environment (root `CLAUDE.md`, "Environment-Aware URLs").
+ */
+declare const MY_API_KEY_URL = "https://my.shipstatic.com/api-key";
+/**
+ * How long an anonymous deployment lives before it expires.
+ *
+ * The lifetime of the public tier, and one fact with several readers. The API
+ * stamps a deployment's `expires` from it and gives a claim code exactly the
+ * same window — a live site with a dead claim link is a coherence bug, so the
+ * two are one constant rather than two that agree. Both MCP transports quote
+ * the duration in prose an agent reads, and derive it from here rather than
+ * writing it out, which they did in eight places until this export existed.
+ *
+ * Seconds, spelled in the name: this platform has both second- and
+ * millisecond-valued durations, and the pair is only safe when each says which
+ * it is.
+ */
+declare const PUBLIC_DEPLOYMENT_TTL_SECONDS: number;
+/**
+ * Universal deploy input — the union of every shape the SDK accepts.
+ *
+ * - **Browser**: `File[]` (typically from `<input type="file">` or drag-and-drop)
+ * - **Node**: `string | string[]` (file or directory path(s) on disk; directories are walked)
+ *
+ * Each platform's SDK narrows its `deploy()` signature to the relevant shape
+ * and rejects anything else at runtime. Use the structural types directly
+ * (`File[]`, `string | string[]`) when writing platform-specific code.
+ */
+type DeployInput = File[] | string | string[];
+/**
+ * Options for deployment creation at the API contract level.
+ * SDK implementations may extend with additional options (timeout, signal, callbacks, etc.).
+ */
+interface DeploymentUploadOptions {
+    /** Optional labels for categorization and filtering */
+    labels?: string[];
+    /**
+     * Which client is making this deploy. Closed, because the server silently
+     * ignores anything outside the set — so an unchecked string turned a typo
+     * into missing analytics rather than an error. See {@link DeploymentVia}.
+     */
+    via?: DeploymentViaType;
+    /**
+     * Optional password that protects this deployment.
+     *
+     * Length: {@link PASSWORD_CONSTRAINTS.MIN_LENGTH} to
+     * {@link PASSWORD_CONSTRAINTS.MAX_LENGTH} characters. Leading and trailing
+     * whitespace is trimmed before validation; internal whitespace is
+     * significant. Visitors are prompted to enter the password before they can
+     * view the deployment — including on any custom domains pointing at it.
+     * To remove protection, redeploy without a password.
+     */
+    password?: string;
+    /** @internal Trigger server-side build. Only available via /upload endpoint. */
+    build?: boolean;
+    /** @internal Trigger server-side prerender. Only available via /upload endpoint. */
+    prerender?: boolean;
+    /** @internal Trigger server-side SPA detection. Only available via /upload endpoint. */
+    spa?: boolean;
+    /** @internal reCAPTCHA proof for the anonymous human deploy channel. Only available via /upload endpoint. */
+    captcha?: string;
+    /**
+     * Makes this deploy replayable instead of repeatable.
+     *
+     * A deploy is not naturally idempotent: a client-side timeout on a slow
+     * one leaves the caller unable to tell "it never landed" from "it landed
+     * and the response was lost", and retrying produces a second deployment.
+     * Send the same key on the retry and the platform replays the original
+     * 201 verbatim rather than creating anything
+     * ({@link IDEMPOTENCY_KEY_CONSTRAINTS.WINDOW_SECONDS}).
+     *
+     * **Agents are the audience.** A human notices a duplicate; an automated
+     * retry does not. Pick a key that identifies the ATTEMPT — a run id, a
+     * commit sha, a uuid minted before the first try — never one minted fresh
+     * on each retry, which would defeat the point.
+     *
+     * The replay is per-caller, and it stores successes only: a failed deploy
+     * retries fresh under the same key.
+     */
+    idempotencyKey?: string;
+}
+/**
+ * What a caller may change on an existing deployment.
+ *
+ * Labels and nothing else: a deployment's content is immutable by design, so
+ * this is the whole mutable surface rather than a subset someone chose.
+ */
+interface DeploymentSetOptions {
+    labels: string[];
+}
+/**
+ * What `domains.set()` may create or change. Every field is optional because
+ * the call is a natural-key upsert: omitting `deployment` reserves the
+ * domain, naming one links or re-points it, and labels travel either way.
+ *
+ * `deployment` is deliberately not nullable — unlinking is refused (400).
+ * See `npm/ship/CLAUDE.md`, "Domain Write Semantics".
+ */
+interface DomainSetOptions {
+    deployment?: string;
+    labels?: string[];
+}
+/** What a caller may set when minting a deploy token. */
+interface TokenCreateOptions {
+    /** Seconds until expiry; omit for a token that never expires. */
+    ttl?: number;
+    labels?: string[];
+}
+/**
+ * Deployment resource interface - the contract all implementations must follow.
+ *
+ * The interface defines the minimal wire contract; SDK implementations may
+ * extend the upload options with runtime concerns (timeout, signal, progress
+ * callbacks) by parameterizing: `DeploymentResource<MyUploadOptions>`. The
+ * default keeps plain `DeploymentResource` valid for wire-only consumers.
+ */
+interface DeploymentResource<UploadOptions extends DeploymentUploadOptions = DeploymentUploadOptions> {
+    upload: (input: DeployInput, options?: UploadOptions) => Promise<DeploymentCreateResponse>;
+    list: (options?: ListOptions) => Promise<DeploymentListResponse>;
+    get: (id: string) => Promise<Deployment>;
+    set: (id: string, options: DeploymentSetOptions) => Promise<Deployment>;
+    delete: (id: string) => Promise<DeploymentDeleteResponse>;
+}
+/**
+ * Domain resource interface - the contract all implementations must follow
+ */
+interface DomainResource {
+    set: (name: string, options?: DomainSetOptions) => Promise<DomainSetResult>;
+    list: (options?: ListOptions) => Promise<DomainListResponse>;
+    get: (name: string) => Promise<Domain>;
+    delete: (name: string) => Promise<DomainDeleteResponse>;
+    verify: (name: string) => Promise<DomainVerifyResponse>;
+    validate: (name: string) => Promise<DomainValidateResponse>;
+    dns: (name: string) => Promise<DomainDnsResponse>;
+    records: (name: string) => Promise<DomainRecordsResponse>;
+    share: (name: string) => Promise<DomainShareResponse>;
+}
+/**
+ * Account resource interface - the contract all implementations must follow
+ */
+interface AccountResource {
+    get: () => Promise<AccountGetResponse>;
+}
+/**
+ * Token resource interface - the contract all implementations must follow
+ */
+interface TokenResource {
+    create: (options?: TokenCreateOptions) => Promise<TokenCreateResponse>;
+    list: (options?: ListOptions) => Promise<TokenListResponse>;
+    get: (token: string) => Promise<Token>;
+    delete: (token: string) => Promise<TokenDeleteResponse>;
+}
+/**
+ * Billing status response from GET /billing/status
+ *
+ * Note: The user's `plan` comes from Account, not here.
+ * This endpoint only returns billing-specific data (usage, portal, etc.)
+ *
+ * If `billing` is null, the user has no active billing.
+ */
+interface BillingStatus {
+    /** Creem billing ID, or null if no active billing */
+    billing: string | null;
+    /** Number of billing units (1 unit = 1 custom domain), null if no billing */
+    units: number | null;
+    /** Billing status from Creem (active, trialing, canceled, etc.), null if no billing */
+    status: string | null;
+    /** Link to Creem customer portal for billing management, null if unavailable */
+    portal: string | null;
+}
+/**
+ * Acknowledgement of `POST /billing/cancel`.
+ *
+ * Cancelling leaves no billing entity to return, so it answers with the
+ * account and the one field of the account the call changed — the plan it
+ * landed on. See {@link DeploymentDeleteResponse} for the law.
+ *
+ * This read `{ success: true, message: 'Subscription canceled successfully…' }`
+ * until 2026-07-29, an anonymous shape that `web/my` redeclared inline and
+ * whose prose no surface ever displayed: both callers await the promise and
+ * discard the body, then compose their own toast. The message was written,
+ * serialized, and thrown away on every cancellation.
+ */
+interface BillingCancelResponse {
+    /** The account whose subscription was cancelled */
+    readonly account: string;
+    /** The plan the account now holds — `free` on a successful cancellation */
+    readonly plan: AccountPlanType;
+}
+/**
+ * Checkout session response from POST /billing/checkout
+ */
+interface CheckoutSession {
+    /** URL to redirect user to Creem checkout page */
+    url: string;
+}
+/**
+ * All activity event types logged in the system.
+ * Uses dot notation consistently: {resource}.{action}
+ */
+type ActivityEvent = 'account.create' | 'account.update' | 'account.delete' | 'account.key.generate' | 'account.plan.paid' | 'account.plan.transition' | 'account.suspended' | 'deployment.create' | 'deployment.update' | 'deployment.delete' | 'deployment.claim' | 'deployment.flagged' | 'domain.create' | 'domain.update' | 'domain.delete' | 'domain.verify' | 'token.create' | 'token.consume' | 'token.delete' | 'admin.account.plan.update' | 'admin.account.ref.update' | 'admin.account.billing.update' | 'admin.account.labels.update' | 'admin.deployment.delete' | 'admin.domain.delete' | 'admin.billing.sync' | 'admin.billing.terminated' | 'admin.impersonate' | 'billing.active' | 'billing.canceled' | 'billing.paused' | 'billing.expired' | 'billing.paid' | 'billing.trialing' | 'billing.scheduled_cancel' | 'billing.unpaid' | 'billing.update' | 'billing.past_due' | 'refund.created' | 'dispute.created' | 'billing.sync' | 'billing.stale' | 'billing.race';
+/**
+ * Activity events visible to users in the dashboard
+ */
+type UserVisibleActivityEvent = 'account.create' | 'account.update' | 'account.delete' | 'account.key.generate' | 'account.plan.transition' | 'deployment.create' | 'deployment.update' | 'deployment.delete' | 'deployment.claim' | 'domain.create' | 'domain.update' | 'domain.delete' | 'domain.verify' | 'token.create' | 'token.consume' | 'token.delete';
+/**
+ * Activity record returned from the API
+ */
+interface Activity {
+    /** The event type */
+    event: ActivityEvent;
+    /** Unix timestamp (seconds) when the activity occurred */
+    created: number;
+    /** Associated deployment ID (if applicable) */
+    deployment?: string;
+    /** Associated domain name (if applicable) */
+    domain?: string;
+    /** JSON-encoded metadata (parse with JSON.parse) */
+    meta?: string;
+}
+/**
+ * Parsed activity metadata.
+ * Different events populate different fields.
+ *
+ * Naming convention: meta booleans are event-scoped predicates and carry
+ * their prefix (`isUpdate`, `wasVerified`, `hasConfig`, `hasPassword`),
+ * while entity booleans are bare nouns (`Deployment.config`,
+ * `Deployment.password`). Two vocabularies, each internally consistent —
+ * deliberate, not drift.
+ */
+interface ActivityMeta {
+    /** Number of files in deployment */
+    files?: number;
+    /** Total size in bytes */
+    size?: number;
+    /** Whether deployment has a ship.json config */
+    hasConfig?: boolean;
+    /** Whether deployment has a password set */
+    hasPassword?: boolean;
+    /** Whether this was an update (vs create) */
+    isUpdate?: boolean;
+    /** Whether domain was already verified */
+    wasVerified?: boolean;
+    /** Previous deployment ID before relinking */
+    previousDeployment?: string;
+    /** Labels that were set/updated */
+    labels?: string[];
+    /** OAuth provider name */
+    provider?: string;
+    /** Account email */
+    email?: string;
+    /** Account display name */
+    name?: string;
+    /** Previous plan */
+    from?: string;
+    /** New plan */
+    to?: string;
+    /** Allow additional fields for future use */
+    [key: string]: unknown;
+}
+/**
+ * Response from GET /activities endpoint
+ */
+interface ActivityListResponse extends ListResponse {
+    /** Array of activities */
+    activities: Activity[];
+}
+/**
+ * File status constants for validation state tracking
+ */
+declare const FileValidationStatus: {
+    /** File is pending validation */
+    readonly PENDING: "pending";
+    /** File failed during processing (before validation) */
+    readonly PROCESSING_ERROR: "processing_error";
+    /** File was excluded by validation warning (not an error) */
+    readonly EXCLUDED: "excluded";
+    /** File failed validation (blocks deployment) */
+    readonly VALIDATION_FAILED: "validation_failed";
+    /** File passed validation and is ready for deployment */
+    readonly READY: "ready";
+};
+type FileValidationStatusType = (typeof FileValidationStatus)[keyof typeof FileValidationStatus];
+/**
+ * A validation issue with a display-ready message
+ *
+ * Issues are either errors (in errors[] array) or warnings (in warnings[] array).
+ * The array position determines severity - no need to duplicate it in the object.
+ */
+interface ValidationIssue {
+    /** File path that triggered this issue */
+    file: string;
+    /** Display-ready message explaining the issue */
+    message: string;
+}
+/**
+ * Minimal file interface required for validation
+ */
+interface ValidatableFile {
+    name: string;
+    size: number;
+    status?: FileValidationStatusType;
+    statusMessage?: string;
+}
+/**
+ * File validation result with severity-based issue reporting
+ *
+ * Validation checks files against constraints and categorizes issues by severity:
+ * - **Errors**: Block deployment (file too large, invalid type, etc.)
+ * - **Warnings**: Exclude files but allow deployment (empty files, etc.)
+ *
+ * @example
+ * ```typescript
+ * const result = validateFiles(files, config);
+ *
+ * if (!result.canDeploy) {
+ *   // Has errors - must fix before deploying
+ *   console.error('Deployment blocked:', result.errors);
+ * } else if (result.warnings.length > 0) {
+ *   // Has warnings - deployment proceeds, some files excluded
+ *   console.warn('Files excluded:', result.warnings);
+ *   deploy(result.validFiles);
+ * } else {
+ *   // All files valid
+ *   deploy(result.validFiles);
+ * }
+ * ```
+ */
+interface FileValidationResult<T extends ValidatableFile> {
+    /** All files with updated status */
+    files: T[];
+    /** Files ready for deployment (status: 'ready') */
+    validFiles: T[];
+    /** Blocking errors that prevent deployment */
+    errors: ValidationIssue[];
+    /** Non-blocking warnings (files excluded but deployment allowed) */
+    warnings: ValidationIssue[];
+    /** Whether deployment can proceed (true if errors.length === 0) */
+    canDeploy: boolean;
+}
+/**
+ * Represents a file that has been uploaded and stored
+ */
+interface UploadedFile {
+    key: string;
+    etag: string;
+    size: number;
+    validated?: boolean;
+}
+/**
+ * Check if a domain is a platform domain (subdomain of our platform).
+ * Platform domains are free and don't require DNS verification.
+ *
+ * @example isPlatformDomain("www.shipstatic.com", "shipstatic.com") → true
+ * @example isPlatformDomain("example.com", "shipstatic.com") → false
+ */
+declare function isPlatformDomain(domain: string, platformDomain: string): boolean;
+/**
+ * Check if a domain is a custom domain (not a platform subdomain).
+ * Custom domains are billable and require DNS verification.
+ *
+ * @example isCustomDomain("example.com", "shipstatic.com") → true
+ * @example isCustomDomain("www.shipstatic.com", "shipstatic.com") → false
+ */
+declare function isCustomDomain(domain: string, platformDomain: string): boolean;
+/**
+ * Extract subdomain from a platform domain.
+ * Returns null if not a platform domain.
+ *
+ * @example extractSubdomain("www.shipstatic.com", "shipstatic.com") → "www"
+ * @example extractSubdomain("example.com", "shipstatic.com") → null
+ */
+declare function extractSubdomain(domain: string, platformDomain: string): string | null;
+/**
+ * Generate HTTPS URL for a deployment hostname.
+ */
+declare function generateDeploymentUrl(deployment: string): string;
+/**
+ * Generate HTTPS URL for a domain.
+ */
+declare function generateDomainUrl(domain: string): string;
+/**
+ * Label validation constraints shared across UI and API.
+ * These rules define the single source of truth for label validation.
+ */
+declare const LABEL_CONSTRAINTS: {
+    /** Minimum label length in characters */
+    readonly MIN_LENGTH: 3;
+    /** Maximum label length in characters (concise labels, matches Stack Overflow's original limit) */
+    readonly MAX_LENGTH: 25;
+    /** Maximum number of labels allowed per resource */
+    readonly MAX_COUNT: 10;
+    /** Allowed separator characters between label segments */
+    readonly SEPARATORS: "._-";
+};
+/**
+ * Label validation pattern.
+ * Must start and end with alphanumeric (a-z, 0-9).
+ * Can contain separators (. _ -) between segments, but not consecutive.
+ *
+ * Valid examples: 'production', 'v1.2.3', 'api_v2', 'us-east-1'
+ * Invalid examples: 'ab' (too short), '-prod' (starts with separator), 'foo--bar' (consecutive separators)
+ */
+declare const LABEL_PATTERN: RegExp;
+/**
+ * Serialize labels array to JSON string for database storage.
+ * Returns null for empty or undefined arrays.
+ *
+ * @example serializeLabels(['web', 'production']) → '["web","production"]'
+ * @example serializeLabels([]) → null
+ * @example serializeLabels(undefined) → null
+ */
+declare function serializeLabels(labels: string[] | undefined): string | null;
+/**
+ * Deserialize labels from JSON string to array.
+ * Always returns an array — empty array for null/empty/invalid input.
+ *
+ * @example deserializeLabels('["web","production"]') → ['web', 'production']
+ * @example deserializeLabels(null) → []
+ * @example deserializeLabels('') → []
+ */
+declare function deserializeLabels(labelsJson: string | null): string[];
+/**
+ * Length constraints for the optional deployment password
+ * (`DeploymentUploadOptions.password`). Single source of truth shared across
+ * platform consumers.
+ */
+declare const PASSWORD_CONSTRAINTS: {
+    /** Minimum password length in characters */
+    readonly MIN_LENGTH: 6;
+    /** Maximum password length in characters */
+    readonly MAX_LENGTH: 128;
+};
+/**
+ * Validate an optional deployment password and return it normalized.
+ *
+ * Absent (`undefined` / `null`) → returns `undefined`. Present → trim
+ * leading/trailing whitespace, then validate against `PASSWORD_CONSTRAINTS`
+ * length bounds (internal whitespace is significant and counts toward
+ * length). Throws `ShipError.validation` on breach; returns the trimmed
+ * value.
+ *
+ * The trim is canonical: at upload, the API hashes the trimmed value; at
+ * unlock, the router trims submissions before hashing. Submission and storage
+ * agree byte-for-byte. Length validation runs on the trimmed value because
+ * that's the user's actual intent — and it disarms a class of invisible
+ * foot-guns (trailing newlines from copy/paste, mobile auto-spacing,
+ * password-manager artifacts).
+ *
+ * Single source of truth shared by SDK (client-side validation, return
+ * ignored) and API (server-side enforcement, return threaded into config).
+ * Length is part of the wire-format contract; strength rules, if added later,
+ * stay server-side. See `CLAUDE.md` "Validation: format vs policy".
+ */
+declare function validatePassword(value: unknown): string | undefined;
 
 /**
  * @file SDK-specific type definitions
@@ -368,7 +2071,7 @@ declare abstract class Ship$1 {
     /**
      * Get current account information (convenience shortcut to `ship.account.get()`).
      */
-    whoami(): Promise<_shipstatic_types.AccountGetResponse>;
+    whoami(): Promise<AccountGetResponse>;
     /**
      * Get platform limits (max file size, file count, total size).
      * Reuses the response fetched during initialization. Per-instance state —
@@ -720,4 +2423,4 @@ declare class Ship extends Ship$1 {
     protected getDeployBodyCreator(): DeployBodyCreator;
 }
 
-export { type ApiDeployOptions, ApiHttp, type ApiHttpOptions, type DeployBody, type DeployBodyContext, type DeployBodyCreator, type DeployFile, type DeploymentOptions, type DeploymentResourceContext, type ExecutionEnvironment, type Fetch, JUNK_DIRECTORIES, type MD5Result, type ResourceContext, Ship, type ShipClientOptions, type ShipEvents, type TokenProvider, __setTestEnvironment, allValidFilesReady, calculateMD5, createAccountResource, createDeploymentResource, createDomainResource, createTokenResource, Ship as default, filterJunk, formatFileSize, getENV, getValidFiles, optimizeDeployPaths, pluralize, processFilesForNode, validateDeployFile, validateDeployPath, validateFileName, validateFiles };
+export { API_KEY, API_PATHS, AUTH_BASE_PATH, type Account, type AccountDeleteResponse, type AccountGetResponse, type AccountKeyResponse, type AccountOverrides, AccountPlan, type AccountPlanType, type AccountResource, type AccountUsage, type Activity, type ActivityEvent, type ActivityListResponse, type ActivityMeta, type ApiDeployOptions, ApiHttp, type ApiHttpOptions, AuthMethod, type AuthMethodType, BLOCKED_EXTENSIONS, type BillingCancelResponse, type BillingStatus, CALLER, type CheckoutSession, DEFAULT_API, DEPLOYMENT_CONFIG_FILENAME, DEPLOY_FIELDS, DEPLOY_TOKEN, type DeployBody, type DeployBodyContext, type DeployBodyCreator, type DeployFile, type DeployInput, type Deployment, type DeploymentCreateResponse, type DeploymentDeleteResponse, type DeploymentListResponse, type DeploymentOptions, type DeploymentResource, type DeploymentResourceContext, type DeploymentSetOptions, DeploymentStatus, type DeploymentStatusType, type DeploymentUploadOptions, DeploymentVia, type DeploymentViaType, type DnsLookup, type DnsProvider, type DnsRecord, type DnsRecordType, type Domain, type DomainDeleteResponse, type DomainDnsResponse, type DomainListResponse, type DomainRecordsResponse, type DomainResource, type DomainSetOptions, type DomainSetResult, type DomainShareResponse, DomainStatus, type DomainStatusType, type DomainValidateResponse, type DomainVerifyResponse, type ErrorResponse, ErrorType, type ExecutionEnvironment, FileValidationStatus as FILE_VALIDATION_STATUS, type Fetch, type FileValidationResult, FileValidationStatus, type FileValidationStatusType, IDEMPOTENCY_KEY_CONSTRAINTS, JUNK_DIRECTORIES, LABEL_CONSTRAINTS, LABEL_PATTERN, type LabelsResponse, type ListOptions, type ListResponse, type MD5Result, MY_API_KEY_URL, OAuthScope, type OAuthScopeType, PASSWORD_CONSTRAINTS, PUBLIC_DEPLOYMENT_TTL_SECONDS, type PingResponse, type PlatformLimits, type ResourceContext, SHIP_ENV, type SPACheckDebug, type SPACheckRequest, type SPACheckResponse, SPA_CHECK_CONSTRAINTS, SPA_DEFAULT_CONFIG, type SetupInstructionsResponse, Ship, type ShipClientOptions, ShipError, type ShipEvents, type StaticFile, type Token, type TokenCreateOptions, type TokenCreateResponse, type TokenDeleteResponse, TokenKind, type TokenKindType, type TokenListResponse, type TokenProvider, type TokenResource, UNBUILT_PROJECT_MARKERS, UNSAFE_FILENAME_CHARS, type UploadedFile, type UserVisibleActivityEvent, type ValidatableFile, type ValidationIssue, WEB_FILE_ACCEPT, __setTestEnvironment, allValidFilesReady, assertShipJsonSyntax, calculateMD5, classifyToken, createAccountResource, createDeploymentResource, createDomainResource, createTokenResource, Ship as default, deserializeLabels, extractSubdomain, filterJunk, formatFileSize, generateDeploymentUrl, generateDomainUrl, getENV, getValidFiles, hasUnbuiltMarker, hasUnsafeChars, isBlockedExtension, isCustomDomain, isDeployment, isPlatformDomain, isShipError, normalizeVia, optimizeDeployPaths, pluralize, processFilesForNode, serializeLabels, validateApiKey, validateApiUrl, validateCaller, validateDeployFile, validateDeployPath, validateDeployToken, validateFileName, validateFiles, validateIdempotencyKey, validatePassword, validateToken };