@vertracloud/blob 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,1063 @@
+// node_modules/@vertracloud/api-types/v1.mjs
+var API_KEY_SCOPES = {
+  "apps:read": {
+    group: "apps",
+    routes: [
+      { method: "GET", path: "/v1/apps/runtimes" },
+      { method: "GET", path: "/v1/apps/status" },
+      { method: "GET", path: "/v1/apps/:id" },
+      { method: "GET", path: "/v1/apps/:id/status" },
+      { method: "GET", path: "/v1/apps/:id/realtime" },
+      { method: "GET", path: "/v1/apps/:id/metrics" },
+      { method: "GET", path: "/v1/apps/:id/logs" },
+      { method: "GET", path: "/v1/apps/:id/download" },
+      { method: "GET", path: "/v1/apps/:id/deploys" },
+      { method: "GET", path: "/v1/apps/:id/deploys/webhook" },
+      { method: "GET", path: "/v1/apps/:id/releases" },
+      { method: "GET", path: "/v1/apps/:id/releases/:release_id/log" },
+      { method: "GET", path: "/v1/apps/:id/network/custom" },
+      { method: "GET", path: "/v1/apps/:id/network/dns" }
+    ]
+  },
+  "apps:write": {
+    group: "apps",
+    routes: [
+      { method: "POST", path: "/v1/apps" },
+      { method: "POST", path: "/v1/apps/:id/start" },
+      { method: "POST", path: "/v1/apps/:id/stop" },
+      { method: "POST", path: "/v1/apps/:id/restart" },
+      { method: "PATCH", path: "/v1/apps/:id/config" },
+      { method: "POST", path: "/v1/apps/:id/deploys/webhook" },
+      { method: "DELETE", path: "/v1/apps/:id/deploys/webhook" },
+      { method: "POST", path: "/v1/apps/:id/network/custom" },
+      { method: "DELETE", path: "/v1/apps/:id/network/custom" },
+      { method: "POST", path: "/v1/apps/:id/network/purge-cache" },
+      { method: "PATCH", path: "/v1/apps/:id/network/subdomain" },
+      { method: "POST", path: "/v1/apps/:id/network/publish" },
+      { method: "DELETE", path: "/v1/apps/:id/network/publish" },
+      { method: "POST", path: "/v1/apps/:id/releases/:release_id/rollback" }
+    ]
+  },
+  "apps:delete": { group: "apps", routes: [{ method: "DELETE", path: "/v1/apps/:id" }] },
+  "apps:envs": {
+    group: "apps",
+    routes: [
+      { method: "GET", path: "/v1/apps/:id/envs" },
+      { method: "POST", path: "/v1/apps/:id/envs" },
+      { method: "DELETE", path: "/v1/apps/:id/envs/:envId" },
+      { method: "GET", path: "/v1/apps/:id/releases/:release_id/rollback" }
+    ]
+  },
+  "apps:files": {
+    group: "apps",
+    routes: [
+      { method: "GET", path: "/v1/apps/:id/files" },
+      { method: "GET", path: "/v1/apps/:id/files/tree" },
+      { method: "GET", path: "/v1/apps/:id/files/content" },
+      { method: "PUT", path: "/v1/apps/:id/files" },
+      { method: "PATCH", path: "/v1/apps/:id/files" },
+      { method: "DELETE", path: "/v1/apps/:id/files" },
+      { method: "POST", path: "/v1/apps/:id/files/upload" }
+    ]
+  },
+  "databases:read": {
+    group: "databases",
+    routes: [
+      { method: "GET", path: "/v1/databases/status" },
+      { method: "GET", path: "/v1/databases/:id" },
+      { method: "GET", path: "/v1/databases/:id/status" },
+      { method: "GET", path: "/v1/databases/:id/metrics" }
+    ]
+  },
+  "databases:write": {
+    group: "databases",
+    routes: [
+      { method: "POST", path: "/v1/databases" },
+      { method: "PUT", path: "/v1/databases/:id" },
+      { method: "POST", path: "/v1/databases/:id/start" },
+      { method: "POST", path: "/v1/databases/:id/stop" },
+      { method: "POST", path: "/v1/databases/:id/reset" }
+    ]
+  },
+  "databases:delete": { group: "databases", routes: [{ method: "DELETE", path: "/v1/databases/:id" }] },
+  "databases:credentials": {
+    group: "databases",
+    routes: [
+      { method: "GET", path: "/v1/databases/:id/credentials/certificate" },
+      { method: "POST", path: "/v1/databases/:id/credentials/certificate/reset" },
+      { method: "POST", path: "/v1/databases/:id/credentials/reset" }
+    ]
+  },
+  "snapshots:read": {
+    group: "snapshots",
+    routes: [
+      { method: "GET", path: "/v1/users/snapshots" },
+      { method: "GET", path: "/v1/users/:id/snapshots" },
+      { method: "GET", path: "/v1/users/:id/snapshots/:snapshot_id/download" }
+    ]
+  },
+  "snapshots:write": {
+    group: "snapshots",
+    routes: [
+      { method: "POST", path: "/v1/users/:id/snapshots" },
+      { method: "POST", path: "/v1/users/:id/snapshots/:snapshot_id/restore" }
+    ]
+  },
+  "account:read": {
+    group: "account",
+    routes: [
+      { method: "GET", path: "/v1/users/me" },
+      { method: "GET", path: "/v1/users/me/sessions" }
+    ]
+  },
+  "account:write": {
+    group: "account",
+    routes: [
+      { method: "PATCH", path: "/v1/users/me" },
+      { method: "POST", path: "/v1/users/me/folders" },
+      { method: "PATCH", path: "/v1/users/me/folders/:folder_id" },
+      { method: "DELETE", path: "/v1/users/me/folders/:folder_id" },
+      { method: "PUT", path: "/v1/users/me/folders/:folder_id/resources/:resource_type/:resource_id" },
+      { method: "DELETE", path: "/v1/users/me/folders/:folder_id/resources/:resource_type/:resource_id" },
+      { method: "PUT", path: "/v1/users/me/favorites/:resource_type/:resource_id" },
+      { method: "DELETE", path: "/v1/users/me/favorites/:resource_type/:resource_id" }
+    ]
+  },
+  "workspaces:read": {
+    group: "workspaces",
+    routes: [
+      { method: "GET", path: "/v1/workspaces" },
+      { method: "GET", path: "/v1/workspaces/:id" },
+      { method: "GET", path: "/v1/workspaces/:id/members" },
+      { method: "GET", path: "/v1/workspaces/:id/roles" },
+      { method: "GET", path: "/v1/workspaces/:id/action-requests" }
+    ]
+  },
+  "workspaces:write": {
+    group: "workspaces",
+    routes: [
+      { method: "POST", path: "/v1/workspaces" },
+      { method: "PUT", path: "/v1/workspaces/:id" },
+      { method: "PUT", path: "/v1/workspaces/:id/members/:user_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/members/:user_id" },
+      { method: "POST", path: "/v1/workspaces/:id/roles" },
+      { method: "PUT", path: "/v1/workspaces/:id/roles/:role_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/roles/:role_id" },
+      { method: "POST", path: "/v1/workspaces/:id/apps/:app_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/apps/:app_id" },
+      { method: "POST", path: "/v1/workspaces/:id/databases/:db_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/databases/:db_id" },
+      { method: "POST", path: "/v1/workspaces/:id/folders" },
+      { method: "PATCH", path: "/v1/workspaces/:id/folders/:folder_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/folders/:folder_id" },
+      { method: "PUT", path: "/v1/workspaces/:id/folders/:folder_id/resources/:resource_type/:resource_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/folders/:folder_id/resources/:resource_type/:resource_id" },
+      { method: "PUT", path: "/v1/workspaces/:id/favorites/:resource_type/:resource_id" },
+      { method: "DELETE", path: "/v1/workspaces/:id/favorites/:resource_type/:resource_id" },
+      { method: "POST", path: "/v1/workspaces/:id/action-requests" }
+    ]
+  },
+  /**
+   * Intentionally left out (dashboard session only): creating invites (a leaked key could grant
+   * access that outlives its revocation), transferring ownership, approving/rejecting action
+   * requests (approval is a human decision) and exporting activities.
+   */
+  /** Delete a workspace (soft delete). Only in the `full` preset, like `apps:delete`. */
+  "workspaces:delete": {
+    group: "workspaces",
+    routes: [{ method: "DELETE", path: "/v1/workspaces/:id" }]
+  },
+  /** List and revoke workspace invites; view, accept and decline your own invite by token. Only in the `full` preset. */
+  "workspaces:invites": {
+    group: "workspaces",
+    routes: [
+      { method: "GET", path: "/v1/workspaces/:id/invites" },
+      { method: "DELETE", path: "/v1/workspaces/:id/invites/:invite_id" },
+      { method: "GET", path: "/v1/workspaces/invites/:token" },
+      { method: "POST", path: "/v1/workspaces/invites/:token/accept" },
+      { method: "POST", path: "/v1/workspaces/invites/:token/decline" }
+    ]
+  },
+  /** Blob Storage (`blob.vertracloud.app`). Upload tokens (`vcup_`) are a separate credential, not a scope. */
+  "blob:read": {
+    group: "blob",
+    routes: [
+      { method: "GET", path: "/v1/blob/objects" },
+      { method: "GET", path: "/v1/blob/objects/:object_id" },
+      { method: "GET", path: "/v1/blob/objects/:object_id/download" },
+      { method: "GET", path: "/v1/blob/shares" },
+      { method: "GET", path: "/v1/blob/rules" },
+      { method: "GET", path: "/v1/blob/stats" },
+      { method: "GET", path: "/v1/blob/s3/credentials" },
+      { method: "GET", path: "/v1/blob/domains" }
+    ]
+  },
+  "blob:write": {
+    group: "blob",
+    routes: [
+      { method: "POST", path: "/v1/blob/objects" },
+      { method: "PATCH", path: "/v1/blob/objects" },
+      { method: "PATCH", path: "/v1/blob/objects/:object_id" },
+      { method: "POST", path: "/v1/blob/objects/copy" },
+      { method: "DELETE", path: "/v1/blob/objects" },
+      { method: "DELETE", path: "/v1/blob/objects/:object_id" },
+      { method: "POST", path: "/v1/blob/uploads" },
+      { method: "GET", path: "/v1/blob/uploads" },
+      { method: "GET", path: "/v1/blob/uploads/:upload_id" },
+      { method: "POST", path: "/v1/blob/uploads/:upload_id/parts" },
+      { method: "POST", path: "/v1/blob/uploads/:upload_id/complete" },
+      { method: "DELETE", path: "/v1/blob/uploads/:upload_id" },
+      { method: "POST", path: "/v1/blob/shares" },
+      { method: "DELETE", path: "/v1/blob/shares/:share_id" },
+      { method: "PUT", path: "/v1/blob/rules" },
+      { method: "PUT", path: "/v1/blob/rules/:prefix" },
+      { method: "DELETE", path: "/v1/blob/rules/:prefix" },
+      { method: "POST", path: "/v1/blob/upload-tokens" },
+      { method: "POST", path: "/v1/blob/domains" },
+      { method: "POST", path: "/v1/blob/domains/:domain_id/verify" },
+      { method: "PATCH", path: "/v1/blob/domains/:domain_id" },
+      { method: "DELETE", path: "/v1/blob/domains/:domain_id" }
+    ]
+  },
+  "billing:read": {
+    group: "billing",
+    routes: [
+      { method: "GET", path: "/v1/orders" },
+      { method: "GET", path: "/v1/orders/:orderId/status" },
+      { method: "GET", path: "/v1/users/me/billing" }
+    ]
+  },
+  /**
+   * Creates a plan order and generates the PIX charge; the payment itself is made by a person in their banking app.
+   * Also saves the billing details (name, address, CPF/CNPJ) an order needs.
+   */
+  "billing:write": {
+    group: "billing",
+    routes: [
+      { method: "POST", path: "/v1/orders" },
+      { method: "POST", path: "/v1/orders/:orderId/initiate/pix" },
+      { method: "PUT", path: "/v1/users/me/billing" }
+    ]
+  },
+  "redeem:write": { group: "billing", routes: [{ method: "POST", path: "/v1/redeem/:code" }] }
+};
+var API_KEY_SCOPE_LIST = Object.keys(API_KEY_SCOPES);
+var WORKSPACE_PERMISSIONS = {
+  "apps:read": { group: "apps" },
+  "apps:manage": { group: "apps" },
+  "apps:lifecycle": { group: "apps" },
+  "apps:envs": { group: "apps" },
+  "apps:files": { group: "apps" },
+  "apps:delete": { group: "apps" },
+  "databases:read": { group: "databases" },
+  "databases:manage": { group: "databases" },
+  "databases:lifecycle": { group: "databases" },
+  "databases:credentials": { group: "databases" },
+  "databases:data": { group: "databases" },
+  "databases:delete": { group: "databases" },
+  "snapshots:read": { group: "snapshots" },
+  "snapshots:manage": { group: "snapshots" },
+  "blob:read": { group: "blob" },
+  "blob:manage": { group: "blob" },
+  "members:read": { group: "members" },
+  "members:manage": { group: "members" },
+  "roles:manage": { group: "roles" },
+  "activities:read": { group: "activities" }
+};
+var WORKSPACE_PERMISSION_LIST = Object.keys(WORKSPACE_PERMISSIONS);
+var WorkspaceFolderColor = { Neutral: "neutral", Red: "red", Orange: "orange", Yellow: "yellow", Green: "green", Blue: "blue", Purple: "purple" };
+var WORKSPACE_FOLDER_COLORS = Object.values(WorkspaceFolderColor);
+var WORKSPACE_ERROR_CODES = {
+  WORKSPACE_NOT_FOUND: "WORKSPACE_NOT_FOUND",
+  WORKSPACE_NAME_ALREADY_EXISTS: "WORKSPACE_NAME_ALREADY_EXISTS",
+  WORKSPACE_MEMBER_LIMIT_REACHED: "WORKSPACE_MEMBER_LIMIT_REACHED",
+  WORKSPACE_ROLE_LIMIT_REACHED: "WORKSPACE_ROLE_LIMIT_REACHED",
+  WORKSPACE_ROLE_IN_USE: "WORKSPACE_ROLE_IN_USE",
+  WORKSPACE_ROLE_NOT_FOUND: "WORKSPACE_ROLE_NOT_FOUND",
+  WORKSPACE_ROLE_NAME_ALREADY_EXISTS: "WORKSPACE_ROLE_NAME_ALREADY_EXISTS",
+  WORKSPACE_PERMISSION_DENIED: "WORKSPACE_PERMISSION_DENIED",
+  WORKSPACE_PERMISSION_ESCALATION: "WORKSPACE_PERMISSION_ESCALATION",
+  WORKSPACE_INVITE_NOT_FOUND: "WORKSPACE_INVITE_NOT_FOUND",
+  WORKSPACE_INVITE_EXPIRED: "WORKSPACE_INVITE_EXPIRED",
+  WORKSPACE_INVITE_EMAIL_MISMATCH: "WORKSPACE_INVITE_EMAIL_MISMATCH",
+  /** 400 — the invited account turned off workspace invites by email. */
+  WORKSPACE_INVITES_DISABLED: "WORKSPACE_INVITES_DISABLED",
+  /** 409 — the account is already the owner or a member of the workspace. */
+  WORKSPACE_ALREADY_MEMBER: "WORKSPACE_ALREADY_MEMBER",
+  WORKSPACE_OWNER_ONLY: "WORKSPACE_OWNER_ONLY",
+  WORKSPACE_ACTION_REQUEST_NOT_FOUND: "WORKSPACE_ACTION_REQUEST_NOT_FOUND",
+  /** 410 — the request expired before anyone decided on it. */
+  WORKSPACE_ACTION_REQUEST_EXPIRED: "WORKSPACE_ACTION_REQUEST_EXPIRED",
+  /** 409 — the request was already approved or rejected. */
+  WORKSPACE_ACTION_REQUEST_ALREADY_DECIDED: "WORKSPACE_ACTION_REQUEST_ALREADY_DECIDED",
+  /** 400 — the requester already has the permission; perform the action directly. */
+  WORKSPACE_ACTION_NOT_NEEDED: "WORKSPACE_ACTION_NOT_NEEDED",
+  /** 400 — the request `params` failed the action's validation (e.g. a snapshot of another resource). */
+  WORKSPACE_ACTION_INVALID_PARAMS: "WORKSPACE_ACTION_INVALID_PARAMS",
+  /** 409 — a pending request already exists for the same action on the same resource. */
+  WORKSPACE_ACTION_REQUEST_PENDING: "WORKSPACE_ACTION_REQUEST_PENDING",
+  WORKSPACE_RESOURCE_FOLDER_NOT_FOUND: "WORKSPACE_RESOURCE_FOLDER_NOT_FOUND",
+  WORKSPACE_RESOURCE_FOLDER_NAME_CONFLICT: "WORKSPACE_RESOURCE_FOLDER_NAME_CONFLICT",
+  WORKSPACE_RESOURCE_NOT_FOUND: "WORKSPACE_RESOURCE_NOT_FOUND",
+  PLAN_RESTRICTED_FEATURE: "PLAN_RESTRICTED_FEATURE"
+};
+var API_ERROR_CODES = {
+  ACCESS_DENIED: "ACCESS_DENIED",
+  API_KEY_INVALID: "API_KEY_INVALID",
+  // Key management (`/v1/users/me/api-keys`) — dashboard-session routes.
+  API_KEY_NOT_FOUND: "API_KEY_NOT_FOUND",
+  API_KEY_LIMIT_REACHED: "API_KEY_LIMIT_REACHED",
+  API_KEY_INVALID_NAME: "API_KEY_INVALID_NAME",
+  API_KEY_INVALID_SCOPES: "API_KEY_INVALID_SCOPES",
+  API_KEY_INVALID_IPS: "API_KEY_INVALID_IPS",
+  API_KEY_IP_DENIED: "API_KEY_IP_DENIED",
+  API_KEY_SCOPE_DENIED: "API_KEY_SCOPE_DENIED",
+  /** 403 — the route only accepts a dashboard session; API keys are refused. */
+  WEBSITE_ONLY: "WEBSITE_ONLY",
+  AUTH_TOKEN_MISSING: "AUTH_TOKEN_MISSING",
+  ACCOUNT_BANNED: "ACCOUNT_BANNED",
+  APP_SHIELD_COOLDOWN: "APP_SHIELD_COOLDOWN",
+  APP_BANNED: "APP_BANNED",
+  APP_ALREADY_PUBLISHED: "APP_ALREADY_PUBLISHED",
+  APP_HAS_NO_SUBDOMAIN: "APP_HAS_NO_SUBDOMAIN",
+  APP_NOT_FOUND: "APP_NOT_FOUND",
+  APP_NOT_PUBLISHED: "APP_NOT_PUBLISHED",
+  APP_ALREADY_IN_WORKSPACE: "APP_ALREADY_IN_WORKSPACE",
+  APP_NOT_FOUND_IN_WORKSPACE: "APP_NOT_FOUND_IN_WORKSPACE",
+  /** 404 — the object does not exist or belongs to another account. */
+  BLOB_OBJECT_NOT_FOUND: "BLOB_OBJECT_NOT_FOUND",
+  /** 409 — the path is taken and `overwrite` is not set. */
+  BLOB_OBJECT_ALREADY_EXISTS: "BLOB_OBJECT_ALREADY_EXISTS",
+  /** 404 — the upload does not exist, is not yours, or is already completed or aborted. */
+  BLOB_UPLOAD_NOT_FOUND: "BLOB_UPLOAD_NOT_FOUND",
+  /** 410 — the upload passed its deadline. */
+  BLOB_UPLOAD_EXPIRED: "BLOB_UPLOAD_EXPIRED",
+  /** 409 — parts are missing or the stored size differs from the declared size. */
+  BLOB_UPLOAD_INCOMPLETE: "BLOB_UPLOAD_INCOMPLETE",
+  /** 409 — more uploads open than the plan allows. */
+  BLOB_UPLOAD_LIMIT: "BLOB_UPLOAD_LIMIT",
+  /** 400 — the SHA-256 sent does not match the file. */
+  BLOB_CHECKSUM_MISMATCH: "BLOB_CHECKSUM_MISMATCH",
+  /** 413 — the file exceeds the plan, single-request upload, folder rule or upload token limit. */
+  BLOB_FILE_TOO_LARGE: "BLOB_FILE_TOO_LARGE",
+  /** 403 — Blob Storage is suspended for the account (grace period, abuse or deletion). */
+  BLOB_NAMESPACE_SUSPENDED: "BLOB_NAMESPACE_SUSPENDED",
+  /** 401 — the upload token does not exist, expired or was revoked. */
+  BLOB_UPLOAD_TOKEN_INVALID: "BLOB_UPLOAD_TOKEN_INVALID",
+  /** 401 — the upload token has no uses left. */
+  BLOB_UPLOAD_TOKEN_EXHAUSTED: "BLOB_UPLOAD_TOKEN_EXHAUSTED",
+  /** 403 — upload tokens only work on the upload routes. */
+  BLOB_UPLOAD_TOKEN_NOT_ALLOWED: "BLOB_UPLOAD_TOKEN_NOT_ALLOWED",
+  /** 403 — the path, size or extension is outside what the upload token allows. */
+  BLOB_UPLOAD_TOKEN_CONSTRAINT: "BLOB_UPLOAD_TOKEN_CONSTRAINT",
+  /** 404 — the share does not exist, was revoked or expired. */
+  BLOB_SHARE_NOT_FOUND: "BLOB_SHARE_NOT_FOUND",
+  /** 410 — the share reached its download limit. */
+  BLOB_SHARE_EXHAUSTED: "BLOB_SHARE_EXHAUSTED",
+  /** 401 — wrong share password. */
+  BLOB_SHARE_PASSWORD_INVALID: "BLOB_SHARE_PASSWORD_INVALID",
+  /** 409 — the `If-Match` of the rule list is outdated; read it again. */
+  BLOB_RULES_CONFLICT: "BLOB_RULES_CONFLICT",
+  /** 409 — more folder rules than the plan allows. */
+  BLOB_RULE_LIMIT: "BLOB_RULE_LIMIT",
+  /** 409 — more custom domains than the plan allows. */
+  BLOB_CUSTOM_DOMAIN_LIMIT: "BLOB_CUSTOM_DOMAIN_LIMIT",
+  /** 409 — the hostname is already in use. */
+  BLOB_CUSTOM_DOMAIN_TAKEN: "BLOB_CUSTOM_DOMAIN_TAKEN",
+  /** 404 — the domain does not exist or belongs to another account. */
+  BLOB_CUSTOM_DOMAIN_NOT_FOUND: "BLOB_CUSTOM_DOMAIN_NOT_FOUND",
+  /** 422 — the file extension is blocked, outside the rule or token, or the content is an executable. */
+  BLOCKED_FILE_TYPE: "BLOCKED_FILE_TYPE",
+  /** 403 — the upload would exceed the storage quota. */
+  STORAGE_QUOTA_EXCEEDED: "STORAGE_QUOTA_EXCEEDED",
+  BUILD_FAILED: "BUILD_FAILED",
+  BUILD_TIMEOUT: "BUILD_TIMEOUT",
+  /** 400 — the order needs complete billing details for the service invoice (name, address and, in Brazil, CPF/CNPJ). Fill them with `PUT /v1/users/me/billing`. */
+  BILLING_DETAILS_INCOMPLETE: "BILLING_DETAILS_INCOMPLETE",
+  /** 400 — billing details failed validation; the field is in `details.path`. */
+  BILLING_DETAILS_INVALID: "BILLING_DETAILS_INVALID",
+  /** 402 — the bank refused the card charge. */
+  CARD_DECLINED: "CARD_DECLINED",
+  /** 400 — the plan can only be paid by PIX. */
+  CARD_NOT_ALLOWED_FOR_PLAN: "CARD_NOT_ALLOWED_FOR_PLAN",
+  CARD_NOT_FOUND: "CARD_NOT_FOUND",
+  CERTIFICATE_NOT_FOUND: "CERTIFICATE_NOT_FOUND",
+  CLEANUP_LANGUAGE_SAME_AS_CURRENT: "CLEANUP_LANGUAGE_SAME_AS_CURRENT",
+  CONTAINER_ALREADY_RUNNING: "CONTAINER_ALREADY_RUNNING",
+  /** 400 — no active coupon with this code. */
+  COUPON_INVALID: "COUPON_INVALID",
+  COUPON_INACTIVE: "COUPON_INACTIVE",
+  COUPON_NOT_STARTED: "COUPON_NOT_STARTED",
+  COUPON_EXPIRED: "COUPON_EXPIRED",
+  /** 400 — the coupon reached its total number of uses. */
+  COUPON_EXHAUSTED: "COUPON_EXHAUSTED",
+  /** 400 — the account already used this coupon as many times as allowed. */
+  COUPON_USER_LIMIT: "COUPON_USER_LIMIT",
+  /** 400 — the coupon is not available to this account. */
+  COUPON_AUDIENCE: "COUPON_AUDIENCE",
+  /** 400 — the coupon does not apply to this plan. */
+  COUPON_PLAN: "COUPON_PLAN",
+  /** 400 — the coupon does not apply to this billing period. */
+  COUPON_DURATION: "COUPON_DURATION",
+  COUPON_PAYMENT_METHOD: "COUPON_PAYMENT_METHOD",
+  CUSTOM_DOMAIN_RECORD_NOT_FOUND: "CUSTOM_DOMAIN_RECORD_NOT_FOUND",
+  CUSTOM_DOMAIN_REGISTRATION_FAILED: "CUSTOM_DOMAIN_REGISTRATION_FAILED",
+  DAILY_QUOTA_EXCEEDED: "DAILY_QUOTA_EXCEEDED",
+  DATABASE_NOT_FOUND: "DATABASE_NOT_FOUND",
+  DATABASE_NOT_RUNNING: "DATABASE_NOT_RUNNING",
+  DATABASE_ALREADY_IN_WORKSPACE: "DATABASE_ALREADY_IN_WORKSPACE",
+  DATABASE_NOT_FOUND_IN_WORKSPACE: "DATABASE_NOT_FOUND_IN_WORKSPACE",
+  DATABASE_PERSISTENCE_FAILED: "DATABASE_PERSISTENCE_FAILED",
+  DEPLOY_FAILED: "DEPLOY_FAILED",
+  DEPLOYMENT_NOT_FOUND: "DEPLOYMENT_NOT_FOUND",
+  DEPLOY_RATE_LIMITED: "DEPLOY_RATE_LIMITED",
+  DOMAIN_ALREADY_IN_USE: "DOMAIN_ALREADY_IN_USE",
+  ENV_LIMIT_EXCEEDED: "ENV_LIMIT_EXCEEDED",
+  ENV_DUPLICATE_KEY: "ENV_DUPLICATE_KEY",
+  ENV_NOT_FOUND: "ENV_NOT_FOUND",
+  FILE_TOO_LARGE: "FILE_TOO_LARGE",
+  FILE_MODIFIED: "FILE_MODIFIED",
+  FILE_NOT_FOUND: "FILE_NOT_FOUND",
+  FILE_OR_FOLDER_NOT_FOUND: "FILE_OR_FOLDER_NOT_FOUND",
+  FORBIDDEN: "FORBIDDEN",
+  FORBIDDEN_DOMAIN: "FORBIDDEN_DOMAIN",
+  FORBIDDEN_PATH: "FORBIDDEN_PATH",
+  FORBIDDEN_KEY: "FORBIDDEN_KEY",
+  FORCED_SNAPSHOT_RATE_LIMIT: "FORCED_SNAPSHOT_RATE_LIMIT",
+  FREE_PLAN_NO_WEB_PUBLISH: "FREE_PLAN_NO_WEB_PUBLISH",
+  /** 403 — the Free plan can no longer create applications or databases; a paid plan is required. */
+  FREE_PLAN_SUSPENDED: "FREE_PLAN_SUSPENDED",
+  INSTALLATION_NOT_FOUND: "INSTALLATION_NOT_FOUND",
+  INSTALL_SHIELD_BLOCKED: "INSTALL_SHIELD_BLOCKED",
+  INSTALL_TIMEOUT: "INSTALL_TIMEOUT",
+  INSTALL_FAILED: "INSTALL_FAILED",
+  INSTALL_CANCELLED: "INSTALL_CANCELLED",
+  INSTALL_OUT_OF_MEMORY: "INSTALL_OUT_OF_MEMORY",
+  INSTALL_QUEUE_FULL: "INSTALL_QUEUE_FULL",
+  INSUFFICIENT_MEMORY: "INSUFFICIENT_MEMORY",
+  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  INVALID_CUSTOM_DOMAIN_FORMAT: "INVALID_CUSTOM_DOMAIN_FORMAT",
+  INVALID_HOSTNAME_FOR_APP: "INVALID_HOSTNAME_FOR_APP",
+  INVALID_LANGUAGE: "INVALID_LANGUAGE",
+  INVALID_MEMORY_FORMAT: "INVALID_MEMORY_FORMAT",
+  INVALID_MONTHS: "INVALID_MONTHS",
+  INVALID_OR_EXPIRED_CODE: "INVALID_OR_EXPIRED_CODE",
+  INVALID_PARAMS: "INVALID_PARAMS",
+  INVALID_PAYLOAD: "INVALID_PAYLOAD",
+  INVALID_PATH: "INVALID_PATH",
+  INVALID_PLAN: "INVALID_PLAN",
+  INVALID_PLAN_NAME: "INVALID_PLAN_NAME",
+  INVALID_RAM_LIMIT: "INVALID_RAM_LIMIT",
+  INVALID_RANGE: "INVALID_RANGE",
+  INVALID_SUBDOMAIN_FORMAT: "INVALID_SUBDOMAIN_FORMAT",
+  INVALID_VERSION: "INVALID_VERSION",
+  INVALID_ZIP: "INVALID_ZIP",
+  INVALID_ZIP_STRUCTURE: "INVALID_ZIP_STRUCTURE",
+  MAIN_FILE_NOT_FOUND: "MAIN_FILE_NOT_FOUND",
+  MAX_APPS_REACHED: "MAX_APPS_REACHED",
+  MAX_DATABASES_REACHED: "MAX_DATABASES_REACHED",
+  MEMORY_BELOW_MINIMUM: "MEMORY_BELOW_MINIMUM",
+  MEMORY_LIMIT_EXCEEDED: "MEMORY_LIMIT_EXCEEDED",
+  MEMORY_MUST_BE_INTEGER: "MEMORY_MUST_BE_INTEGER",
+  MEMORY_REQUIRED: "MEMORY_REQUIRED",
+  MISSING_HEADERS: "MISSING_HEADERS",
+  MISSING_PLAN_OR_MONTHS: "MISSING_PLAN_OR_MONTHS",
+  MISSING_CONTENT: "MISSING_CONTENT",
+  NOT_AN_UPGRADE: "NOT_AN_UPGRADE",
+  NO_AUTHORIZED_PATHS: "NO_AUTHORIZED_PATHS",
+  NO_CHANGES_PROVIDED: "NO_CHANGES_PROVIDED",
+  NO_CUSTOM_DOMAIN: "NO_CUSTOM_DOMAIN",
+  NO_FIELDS_TO_UPDATE: "NO_FIELDS_TO_UPDATE",
+  NO_FILE_UPLOADED: "NO_FILE_UPLOADED",
+  OPERATION_IN_PROGRESS: "OPERATION_IN_PROGRESS",
+  ORDER_NOT_FOUND: "ORDER_NOT_FOUND",
+  ORDER_NOT_PAID: "ORDER_NOT_PAID",
+  ORDER_NOT_PAYABLE: "ORDER_NOT_PAYABLE",
+  ORDER_NOT_REFUNDED: "ORDER_NOT_REFUNDED",
+  /** 404 — the order has no payment receipt (unpaid, redeemed code or paid before receipts existed). */
+  ORDER_RECEIPT_UNAVAILABLE: "ORDER_RECEIPT_UNAVAILABLE",
+  OWNER_APP_WITHOUT_LIMITS: "OWNER_APP_WITHOUT_LIMITS",
+  PAYLOAD_TOO_LARGE: "PAYLOAD_TOO_LARGE",
+  /** 409 — a folder in the path is an existing file (writing `app/x.js` when `app` is a file). */
+  PATH_IS_FILE: "PATH_IS_FILE",
+  PENDING_ORDER_LIMIT_REACHED: "PENDING_ORDER_LIMIT_REACHED",
+  PAYMENT_METHOD_UNAVAILABLE: "PAYMENT_METHOD_UNAVAILABLE",
+  /** 403 — the plan does not include automatic rollback (`deploy.auto_rollback: true` below Intermediary). */
+  PLAN_DOES_NOT_SUPPORT_AUTO_ROLLBACK: "PLAN_DOES_NOT_SUPPORT_AUTO_ROLLBACK",
+  PLAN_DOES_NOT_SUPPORT_CUSTOM_DOMAIN: "PLAN_DOES_NOT_SUPPORT_CUSTOM_DOMAIN",
+  PLAN_DOES_NOT_SUPPORT_CUSTOM_SUBDOMAIN: "PLAN_DOES_NOT_SUPPORT_CUSTOM_SUBDOMAIN",
+  /** 403 — the plan does not include rollback to earlier releases. */
+  PLAN_DOES_NOT_SUPPORT_ROLLBACK: "PLAN_DOES_NOT_SUPPORT_ROLLBACK",
+  PLAN_DOES_NOT_SUPPORT_WEB_PUBLISH: "PLAN_DOES_NOT_SUPPORT_WEB_PUBLISH",
+  /** 403 — the plan does not include zero-downtime deploys (`deploy.zero_downtime: "on"` below Enterprise). */
+  PLAN_DOES_NOT_SUPPORT_ZERO_DOWNTIME: "PLAN_DOES_NOT_SUPPORT_ZERO_DOWNTIME",
+  PLAN_MISMATCH_FOR_RENEWAL: "PLAN_MISMATCH_FOR_RENEWAL",
+  PLAN_NOT_ALLOWED: "PLAN_NOT_ALLOWED",
+  RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+  REFUND_AMOUNT_EXCEEDS_PRICE: "REFUND_AMOUNT_EXCEEDS_PRICE",
+  /** 409 — the release is already the active one. */
+  RELEASE_ALREADY_ACTIVE: "RELEASE_ALREADY_ACTIVE",
+  /** 410 — the release's kept code has expired or is outside the limit of the plan. */
+  RELEASE_EXPIRED: "RELEASE_EXPIRED",
+  /** 404 — the release does not exist or belongs to another application. */
+  RELEASE_NOT_FOUND: "RELEASE_NOT_FOUND",
+  REPO_ALREADY_LINKED: "REPO_ALREADY_LINKED",
+  RESTORE_COOLDOWN: "RESTORE_COOLDOWN",
+  SNAPSHOT_ENGINE_MISMATCH: "SNAPSHOT_ENGINE_MISMATCH",
+  SNAPSHOT_FAILED: "SNAPSHOT_FAILED",
+  SNAPSHOT_IMPORT_FAILED: "SNAPSHOT_IMPORT_FAILED",
+  SNAPSHOT_NOT_FOUND: "SNAPSHOT_NOT_FOUND",
+  SNAPSHOT_RATE_LIMITED: "SNAPSHOT_RATE_LIMITED",
+  SNAPSHOT_TYPE_MISMATCH: "SNAPSHOT_TYPE_MISMATCH",
+  SNAPSHOT_TOO_LARGE: "SNAPSHOT_TOO_LARGE",
+  SOURCE_CONFLICT: "SOURCE_CONFLICT",
+  SOURCE_REQUIRED: "SOURCE_REQUIRED",
+  STORAGE_ABOVE_NEW_LIMIT: "STORAGE_ABOVE_NEW_LIMIT",
+  SUBDOMAIN_CHANGE_RATE_LIMITED: "SUBDOMAIN_CHANGE_RATE_LIMITED",
+  SUBDOMAIN_FORBIDDEN: "SUBDOMAIN_FORBIDDEN",
+  SUBDOMAIN_TAKEN: "SUBDOMAIN_TAKEN",
+  /** 400 — the CPF or CNPJ is not valid. */
+  TAX_ID_INVALID: "TAX_ID_INVALID",
+  TYPE_MISMATCH: "TYPE_MISMATCH",
+  USER_LIMITS_NOT_FOUND: "USER_LIMITS_NOT_FOUND",
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  USER_NOT_IN_WORKSPACE: "USER_NOT_IN_WORKSPACE",
+  DATABASE_BANNED: "DATABASE_BANNED",
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  ZIP_TOO_LARGE: "ZIP_TOO_LARGE",
+  ZIP_TOO_SMALL: "ZIP_TOO_SMALL",
+  STORAGE_FULL: "STORAGE_FULL",
+  TARGET_IS_DIRECTORY: "TARGET_IS_DIRECTORY",
+  ...WORKSPACE_ERROR_CODES
+};
+var BlobVisibility = { PUBLIC: "public", PRIVATE: "private" };
+var BlobContentDisposition = {
+  INLINE: "inline",
+  ATTACHMENT: "attachment"
+};
+var BlobUploadMode = { SINGLE: "single", MULTIPART: "multipart" };
+var BlobUploadStatus = {
+  PENDING: "pending",
+  COMPLETED: "completed",
+  ABORTED: "aborted",
+  EXPIRED: "expired"
+};
+var BlobCustomDomainStatus = {
+  PENDING: "pending",
+  ACTIVE: "active",
+  FAILED: "failed",
+  SUSPENDED: "suspended"
+};
+
+// src/errors.ts
+var BlobError = class extends Error {
+  constructor(status, body, retryAfter) {
+    super(body.message || body.code);
+    this.name = "BlobError";
+    this.status = status;
+    this.code = body.code;
+    this.details = body.details;
+    this.retryAfter = retryAfter;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return { name: this.name, status: this.status, code: this.code, message: this.message, details: this.details, retryAfter: this.retryAfter };
+  }
+  toString() {
+    return `${this.name} [${this.status}] ${this.code}: ${this.message}`;
+  }
+};
+var clientError = (code, message, status = 0) => new BlobError(status, { code, message });
+
+// src/source.ts
+function toSource(data, size) {
+  if (typeof data === "string") return bytes(new TextEncoder().encode(data));
+  if (data instanceof Uint8Array) return bytes(data);
+  if (data instanceof ArrayBuffer) return bytes(new Uint8Array(data));
+  if (typeof Blob !== "undefined" && data instanceof Blob) return { size: data.size, read: async (s, e) => data.slice(s, e) };
+  if (typeof data.getReader === "function") {
+    if (typeof size !== "number" || !Number.isInteger(size) || size < 0) throw clientError("INVALID_ARGUMENT", "`size` is required when the data is a ReadableStream");
+    return stream(data, size);
+  }
+  throw clientError("INVALID_ARGUMENT", "Unsupported data type: use Blob, File, ArrayBuffer, Uint8Array, ReadableStream or string");
+}
+var bytes = (u8) => ({ size: u8.byteLength, read: async (s, e) => u8.subarray(s, e) });
+function stream(readable, size) {
+  const reader = readable.getReader();
+  let rest = new Uint8Array(0);
+  let pos = 0;
+  const take = async (n, keep) => {
+    const out = new Uint8Array(keep ? n : 0);
+    let got = 0;
+    while (got < n) {
+      if (rest.length === 0) {
+        const { done, value } = await reader.read();
+        if (done) throw clientError("INVALID_ARGUMENT", "The stream ended before `size` bytes were read");
+        rest = value;
+        continue;
+      }
+      const m = Math.min(n - got, rest.length);
+      if (keep) out.set(rest.subarray(0, m), got);
+      rest = rest.subarray(m);
+      got += m;
+    }
+    pos += n;
+    return out;
+  };
+  return {
+    size,
+    async read(start, end) {
+      if (start < pos) throw clientError("INVALID_ARGUMENT", "A stream can only be read forward");
+      if (start > pos) await take(start - pos, false);
+      return take(end - start, true);
+    }
+  };
+}
+
+// src/transport.ts
+var fetchTransport = (fetchImpl) => async (req) => {
+  const init = { method: req.method, headers: req.headers, body: req.body ?? null, signal: req.signal };
+  if (req.credentials) init.credentials = req.credentials;
+  const res = await fetchImpl(req.url, init);
+  return { status: res.status, retryAfter: res.headers.get("retry-after"), text: await res.text() };
+};
+var xhrTransport = (req) => new Promise((resolve, reject) => {
+  const xhr = new XMLHttpRequest();
+  xhr.open(req.method, req.url);
+  for (const [k, v] of Object.entries(req.headers)) xhr.setRequestHeader(k, v);
+  if (req.credentials === "include") xhr.withCredentials = true;
+  if (req.onUploadProgress) {
+    const report = req.onUploadProgress;
+    xhr.upload.onprogress = (e) => report(e.loaded);
+  }
+  const onAbort = () => xhr.abort();
+  req.signal.addEventListener("abort", onAbort, { once: true });
+  const done = () => req.signal.removeEventListener("abort", onAbort);
+  xhr.onload = () => {
+    done();
+    resolve({ status: xhr.status, retryAfter: xhr.status === 429 ? xhr.getResponseHeader("Retry-After") : null, text: xhr.responseText });
+  };
+  xhr.onerror = xhr.onabort = xhr.ontimeout = () => {
+    done();
+    reject(new Error("request failed"));
+  };
+  xhr.send(req.body ?? null);
+});
+var aborted = () => clientError("ABORTED", "The operation was aborted");
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(aborted());
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(aborted());
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/client.ts
+var SIMPLE_UPLOAD_MAX = 5 * 1024 * 1024;
+var PART_URLS_PER_REQUEST = 100;
+var MAX_BACKOFF_MS = 8e3;
+var snake = (key) => key.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+function toWire(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) out[snake(key)] = value instanceof Date ? value.toISOString() : value;
+  }
+  return out;
+}
+var BlobClient = class {
+  constructor(options = {}) {
+    this.shares = {
+      create: (objectId, options = {}) => {
+        const { signal, timeout, ...rest } = options;
+        return this.api("POST", "/shares", { json: { ...toWire(rest), object_id: objectId }, signal, timeout });
+      },
+      list: (options = {}) => this.api("GET", "/shares", { query: { object_id: options.objectId }, signal: options.signal, timeout: options.timeout }),
+      revoke: async (shareId, options = {}) => {
+        await this.api("DELETE", `/shares/${enc(shareId)}`, options);
+      }
+    };
+    this.rules = {
+      get: (options = {}) => this.api("GET", "/rules", options),
+      /** Replaces the whole list. `etag` is the one from the list you read; a stale one fails with `BLOB_RULES_CONFLICT`. */
+      set: (rules, etag, options = {}) => this.api("PUT", "/rules", { json: { rules: rules.map((rule) => toWire(rule)) }, headers: { "If-Match": etag }, ...options }),
+      /** Creates or changes the rule of one folder; returns the whole list and its new etag. */
+      put: (prefix, rule, options = {}) => this.api("PUT", `/rules/${enc(prefix)}`, { json: toWire(rule), ...options }),
+      delete: (prefix, options = {}) => this.api("DELETE", `/rules/${enc(prefix)}`, options)
+    };
+    this.domains = {
+      list: (options = {}) => this.api("GET", "/domains", options),
+      add: (hostname, options = {}) => {
+        const { signal, timeout, prefix, web_content } = options;
+        return this.api("POST", "/domains", { json: { hostname, ...prefix ? { prefix } : {}, ...web_content === void 0 ? {} : { web_content } }, signal, timeout });
+      },
+      update: (domainId, body, options = {}) => this.api("PATCH", `/domains/${enc(domainId)}`, { json: body, signal: options.signal, timeout: options.timeout }),
+      verify: (domainId, options = {}) => this.api("POST", `/domains/${enc(domainId)}/verify`, options),
+      remove: async (domainId, options = {}) => {
+        await this.api("DELETE", `/domains/${enc(domainId)}`, options);
+      }
+    };
+    if (options.apiKey && options.uploadToken) throw clientError("INVALID_ARGUMENT", "Pass either `apiKey` or `uploadToken`, not both");
+    this.apiKey = options.apiKey ?? options.uploadToken;
+    this.baseUrl = (options.baseUrl ?? "https://blob.vertracloud.app/v1").replace(/\/+$/, "");
+    this.fetchImpl = options.fetch;
+    this.credentials = options.credentials;
+    this.workspaceId = options.workspaceId;
+    this.extraHeaders = options.headers ?? {};
+    this.partConcurrency = Math.max(1, Math.floor(options.partConcurrency ?? 4));
+    this.maxRetries = Math.max(0, Math.floor(options.maxRetries ?? 3));
+    this.retryDelayMs = options.retryDelayMs ?? 300;
+    this.timeout = options.timeout ?? 3e4;
+    this.uploadTimeout = options.uploadTimeout ?? 3e5;
+  }
+  // ---------------------------------------------------------------------------
+  // Upload
+  // ---------------------------------------------------------------------------
+  /**
+   * Uploads a file. Up to 5 MB it is one `POST /objects`; above that it starts a direct upload and
+   * follows the mode the API picks: one signed PUT, or parts sent in parallel. Returns the object.
+   * Aborting `signal` during a direct upload cancels it on the server (best effort).
+   */
+  async put(path, data, options = {}) {
+    const { size, onProgress, onUpload, signal, timeout, ...write } = options;
+    const src = toSource(data, size);
+    const ctx = { signal, timeout, onProgress };
+    if (src.size <= SIMPLE_UPLOAD_MAX) return this.putSimple(path, src, write, ctx);
+    const upload = await this.api("POST", "/uploads", { json: { ...toWire(write), path, size: src.size }, signal, timeout });
+    onUpload?.(upload);
+    return this.transfer(upload, src, ctx, true, /* @__PURE__ */ new Set());
+  }
+  /** Continues an interrupted direct upload, sending only the parts the server does not have yet. `data` must be the same file. */
+  async resume(uploadId, data, options = {}) {
+    const { size, onProgress, signal, timeout } = options;
+    const src = toSource(data, size);
+    const upload = await this.api("GET", `/uploads/${enc(uploadId)}`, { signal, timeout });
+    return this.transfer(upload, src, { signal, timeout, onProgress }, false, new Set(upload.uploaded_parts ?? []));
+  }
+  /** Direct uploads still in progress. */
+  listUploads(options = {}) {
+    return this.api("GET", "/uploads", options);
+  }
+  /** Aborts a direct upload and frees its reserved storage. Repeating it is not an error. */
+  async abortUpload(uploadId, options = {}) {
+    await this.api("DELETE", `/uploads/${enc(uploadId)}`, options);
+  }
+  async putSimple(path, src, write, ctx) {
+    const { metadata, ...rest } = write;
+    const query = toWire({ ...rest, path, ...metadata ? { metadata: JSON.stringify(metadata) } : {} });
+    const form = new FormData();
+    form.append("file", new Blob([await src.read(0, src.size)]), path.split("/").pop() || "file");
+    const object = await this.api("POST", "/objects", {
+      query,
+      body: form,
+      signal: ctx.signal,
+      timeout: ctx.timeout ?? this.uploadTimeout,
+      onUploadProgress: ctx.onProgress && ((loaded) => ctx.onProgress?.({ loaded: Math.min(loaded, src.size), total: src.size }))
+    });
+    ctx.onProgress?.({ loaded: src.size, total: src.size });
+    return object;
+  }
+  async transfer(upload, src, ctx, abortOnUserAbort, skip) {
+    if (src.size !== upload.size) throw clientError("INVALID_ARGUMENT", `The data has ${src.size} bytes but the upload was created for ${upload.size}`);
+    try {
+      if (upload.mode === "single") await this.putSingle(upload, src, ctx);
+      else await this.putParts(upload, src, ctx, skip);
+      return await this.api("POST", `/uploads/${enc(upload.id)}/complete`, { signal: ctx.signal, timeout: ctx.timeout });
+    } catch (error) {
+      if (abortOnUserAbort && ctx.signal?.aborted) await this.abortUpload(upload.id, { timeout: 5e3 }).catch(() => {
+      });
+      throw error;
+    }
+  }
+  async putSingle(upload, src, ctx) {
+    if (!upload.url) throw clientError("INVALID_RESPONSE", "The upload has no URL");
+    const body = await src.read(0, src.size);
+    await this.putBytes(upload.url, upload.headers, body, ctx.signal, ctx.onProgress && ((loaded) => ctx.onProgress?.({ loaded: Math.min(loaded, src.size), total: src.size })));
+    ctx.onProgress?.({ loaded: src.size, total: src.size });
+  }
+  async putParts(upload, src, ctx, skip) {
+    const { part_size: partSize, part_count: partCount } = upload;
+    if (!partSize || !partCount) throw clientError("INVALID_RESPONSE", "The multipart upload has no part layout");
+    const range = (n) => [(n - 1) * partSize, Math.min(n * partSize, src.size)];
+    const pending = [];
+    let done = 0;
+    for (let n = 1; n <= partCount; n++) {
+      if (skip.has(n)) done += range(n)[1] - range(n)[0];
+      else pending.push(n);
+    }
+    const total = src.size;
+    const inflight = /* @__PURE__ */ new Map();
+    const report = () => {
+      let loaded = done;
+      for (const v of inflight.values()) loaded += v;
+      ctx.onProgress?.({ loaded: Math.min(loaded, total), total });
+    };
+    if (done > 0) report();
+    const ctl = new AbortController();
+    const onUserAbort = () => ctl.abort();
+    ctx.signal?.addEventListener("abort", onUserAbort, { once: true });
+    if (ctx.signal?.aborted) ctl.abort();
+    const urls = /* @__PURE__ */ new Map();
+    let cursor = 0;
+    let failed = false;
+    let lock = Promise.resolve();
+    const next = () => {
+      const run = lock.then(async () => {
+        if (failed || cursor >= pending.length) return null;
+        const n = pending[cursor];
+        if (!urls.has(n)) {
+          const batch = pending.slice(cursor, cursor + PART_URLS_PER_REQUEST);
+          const parts = await this.api("POST", `/uploads/${enc(upload.id)}/parts`, { json: { part_numbers: batch }, signal: ctl.signal, timeout: ctx.timeout });
+          for (const part2 of parts) urls.set(part2.part_number, part2);
+        }
+        const part = urls.get(n);
+        if (!part) throw clientError("INVALID_RESPONSE", `The API did not return a URL for part ${n}`);
+        cursor++;
+        const [start, end] = range(n);
+        return { n, part, bytes: await src.read(start, end), size: end - start };
+      });
+      lock = run.catch(() => {
+      });
+      return run;
+    };
+    const worker = async () => {
+      for (let job = await next(); job; job = await next()) {
+        await this.putBytes(
+          job.part.url,
+          job.part.headers,
+          job.bytes,
+          ctl.signal,
+          ctx.onProgress && ((loaded) => {
+            inflight.set(job.n, Math.min(loaded, job.size));
+            report();
+          })
+        );
+        inflight.delete(job.n);
+        done += job.size;
+        report();
+      }
+    };
+    try {
+      await Promise.all(
+        Array.from(
+          { length: Math.min(this.partConcurrency, pending.length) },
+          () => worker().catch((error) => {
+            failed = true;
+            ctl.abort();
+            throw error;
+          })
+        )
+      );
+    } finally {
+      ctx.signal?.removeEventListener("abort", onUserAbort);
+    }
+  }
+  /** PUT to a signed URL with exactly the headers the API returned. No credentials are attached. Retried on 5xx and network errors. */
+  async putBytes(url, headers, body, signal, onUploadProgress) {
+    const res = await this.exec({ method: "PUT", url, headers: { ...headers }, body, signal, timeout: this.uploadTimeout, retry: true, onUploadProgress });
+    if (res.status < 200 || res.status >= 300) throw clientError("UPLOAD_FAILED", `The storage rejected the upload (HTTP ${res.status})`, res.status);
+  }
+  // ---------------------------------------------------------------------------
+  // Objects
+  // ---------------------------------------------------------------------------
+  /** One page of objects plus the `folders` found under the prefix, and the `cursor` of the next page (`null` on the last). */
+  listPage(options = {}) {
+    const { signal, timeout, ...query } = options;
+    return this.api("GET", "/objects", { query: toWire(query), signal, timeout });
+  }
+  /** Iterates every object that matches, fetching pages as needed. */
+  async *list(options = {}) {
+    let cursor;
+    do {
+      const page = await this.listPage({ ...options, cursor });
+      yield* page.objects;
+      cursor = page.cursor ?? void 0;
+    } while (cursor);
+  }
+  get(id, options = {}) {
+    return this.api("GET", `/objects/${enc(id)}`, options);
+  }
+  update(id, changes, options = {}) {
+    return this.api("PATCH", `/objects/${enc(id)}`, { json: toWire(changes), ...options });
+  }
+  /** Applies the same changes to any number of objects (sent in batches of 100, the API limit); one result per id, in the order of `ids`. */
+  async updateMany(ids, changes, options = {}) {
+    const wire = toWire(changes);
+    const results = [];
+    for (let i = 0; i === 0 || i < ids.length; i += 100) {
+      const batch = await this.api("PATCH", "/objects", { json: { ids: ids.slice(i, i + 100), changes: wire }, ...options });
+      results.push(...batch);
+    }
+    return results;
+  }
+  copy(id, path, options = {}) {
+    const { signal, timeout, ...rest } = options;
+    return this.api("POST", "/objects/copy", { json: { ...toWire(rest), source: id, path }, signal, timeout });
+  }
+  /** Moves or renames an object; the id stays the same. */
+  move(id, path, options = {}) {
+    return this.copy(id, path, { ...options, move: true });
+  }
+  async delete(id, options = {}) {
+    await this.api("DELETE", `/objects/${enc(id)}`, options);
+  }
+  /**
+   * Deletes by `ids` or by folder `prefix`, repeating while the API reports `remaining`
+   * (it deletes up to 1000 per call). The result merges every round.
+   */
+  async deleteMany(input, options = {}) {
+    const total = { deleted: [], not_found: [], remaining: false };
+    let ids = "ids" in input ? [...input.ids] : void 0;
+    for (; ; ) {
+      const body = ids ? { ids: ids.slice(0, 1e3) } : { prefix: input.prefix };
+      const res = await this.api("DELETE", "/objects", { json: body, ...options });
+      total.deleted.push(...res.deleted);
+      total.not_found.push(...res.not_found);
+      if (ids) {
+        const seen = /* @__PURE__ */ new Set([...total.deleted, ...total.not_found]);
+        ids = ids.filter((id) => !seen.has(id));
+      }
+      if (ids ? ids.length === 0 : !res.remaining) return total;
+      if (res.deleted.length + res.not_found.length === 0) throw clientError("INVALID_RESPONSE", "deleteMany made no progress");
+    }
+  }
+  /** A temporary download link (`{ url, expires_at }`). It cannot be revoked. */
+  downloadUrl(id, options = {}) {
+    const { signal, timeout, ...rest } = options;
+    const query = { ...toWire(rest), redirect: false };
+    return this.api("GET", `/objects/${enc(id)}/download`, { query, signal, timeout });
+  }
+  /**
+   * Builds an image-transformation URL from a public object (or its public URL). Pure: no request is made.
+   * Throws for a private object, which has no public URL.
+   */
+  imageUrl(source, options = {}) {
+    const raw = typeof source === "string" ? source : source.url;
+    if (!raw) throw clientError("INVALID_ARGUMENT", "Only public objects can be transformed; this object is private");
+    const url = new URL(raw);
+    const params = [
+      ["w", options.width],
+      ["h", options.height],
+      ["fit", options.fit],
+      ["format", options.format],
+      ["q", options.quality]
+    ];
+    for (const [key, value] of params) if (value !== void 0) url.searchParams.set(key, String(value));
+    return url.toString();
+  }
+  // ---------------------------------------------------------------------------
+  // Account, tokens, S3
+  // ---------------------------------------------------------------------------
+  stats(options = {}) {
+    return this.api("GET", "/stats", options);
+  }
+  /** Creates a token that fixes every constraint you pass; hand it to a browser as `uploadToken`. */
+  createUploadToken(options = {}) {
+    const { signal, timeout, ...rest } = options;
+    return this.api("POST", "/upload-tokens", { json: toWire(rest), signal, timeout });
+  }
+  /** S3-compatible credentials derived from the API key, for aws-cli, rclone or boto3. */
+  s3Credentials(options = {}) {
+    return this.api("GET", "/s3/credentials", options);
+  }
+  // ---------------------------------------------------------------------------
+  // HTTP
+  // ---------------------------------------------------------------------------
+  /** One API call: builds the URL, authenticates, unwraps `{ response }` and turns an error envelope into a `BlobError`. */
+  async api(method, path, call = {}) {
+    const query = new URLSearchParams();
+    for (const [key, value] of Object.entries({ ...call.query, workspace_id: this.workspaceId })) {
+      if (value !== void 0 && value !== null) query.set(key, String(value));
+    }
+    const headers = { accept: "application/json", ...this.extraHeaders, ...call.headers };
+    if (this.apiKey) headers.authorization = `Bearer ${this.apiKey}`;
+    let body = call.body;
+    if (call.json !== void 0) {
+      body = JSON.stringify(call.json);
+      headers["content-type"] = "application/json";
+    }
+    const qs = query.toString();
+    const res = await this.exec({
+      method,
+      url: `${this.baseUrl}${path}${qs ? `?${qs}` : ""}`,
+      headers,
+      body,
+      credentials: this.credentials,
+      signal: call.signal,
+      timeout: call.timeout ?? this.timeout,
+      retry: method === "GET",
+      onUploadProgress: call.onUploadProgress
+    });
+    let parsed;
+    if (res.text) {
+      try {
+        parsed = JSON.parse(res.text);
+      } catch {
+        if (res.status >= 200 && res.status < 300) throw clientError("INVALID_RESPONSE", "The API returned a body that is not JSON", res.status);
+      }
+    }
+    if (res.status >= 200 && res.status < 300) return parsed?.response ?? null;
+    const err = parsed ?? {};
+    const retryAfter = Number(res.retryAfter);
+    throw new BlobError(res.status, { code: typeof err.code === "string" ? err.code : `HTTP_${res.status}`, message: typeof err.message === "string" ? err.message : void 0, details: err.details }, res.retryAfter && Number.isFinite(retryAfter) ? retryAfter : void 0);
+  }
+  /** Sends a request, retrying 5xx and network errors when `req.retry` (never 429). */
+  async exec(req) {
+    const retries = req.retry ? this.maxRetries : 0;
+    for (let attempt = 0; ; attempt++) {
+      try {
+        const res = await this.once(req);
+        if (res.status < 500 || attempt >= retries) return res;
+      } catch (error) {
+        if (!(error instanceof BlobError) || error.code !== "NETWORK_ERROR" && error.code !== "TIMEOUT" || attempt >= retries) throw error;
+      }
+      await sleep(Math.min(this.retryDelayMs * 2 ** attempt, MAX_BACKOFF_MS) * (0.5 + Math.random() / 2), req.signal);
+    }
+  }
+  async once(req) {
+    const user = req.signal;
+    if (user?.aborted) throw aborted();
+    const ctl = new AbortController();
+    const onAbort = () => ctl.abort();
+    user?.addEventListener("abort", onAbort, { once: true });
+    let timedOut = false;
+    const timer = req.timeout ? setTimeout(() => {
+      timedOut = true;
+      ctl.abort();
+    }, req.timeout) : void 0;
+    const useXhr = req.onUploadProgress && !this.fetchImpl && typeof XMLHttpRequest !== "undefined";
+    try {
+      const send = useXhr ? xhrTransport : fetchTransport(this.fetchImpl ?? ((input, init) => globalThis.fetch(input, init)));
+      return await send({ ...req, signal: ctl.signal });
+    } catch {
+      if (user?.aborted) throw aborted();
+      if (timedOut) throw clientError("TIMEOUT", "The request timed out");
+      throw clientError("NETWORK_ERROR", "The request failed before a response was received");
+    } finally {
+      clearTimeout(timer);
+      user?.removeEventListener("abort", onAbort);
+    }
+  }
+};
+var enc = encodeURIComponent;
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  BlobClient,
+  BlobContentDisposition,
+  BlobCustomDomainStatus,
+  BlobError,
+  BlobUploadMode,
+  BlobUploadStatus,
+  BlobVisibility,
+  VERSION
+};
+//# sourceMappingURL=index.js.map