@lizard-build/sdk 0.1.34 → 0.1.36

package/dist/index.d.ts

@@ -271,6 +271,11 @@ interface SandboxInfo {
     template: string;
     startedAt: string;
     endAt: string;
+    /** Region the sandbox runs in — the volume's region when one is attached. */
+    region?: string;
+    status?: string;
+    cpus?: number;
+    memoryMb?: number;
     metadata?: Record<string, string>;
 }
 interface SandboxOpts extends ConnectionOpts {
@@ -287,6 +292,17 @@ interface SandboxOpts extends ConnectionOpts {
     metadata?: Record<string, string>;
     envs?: Record<string, string>;
     timeoutMs?: number;
+    /**
+     * Region to run the sandbox in, e.g. `'us-east-1'`.
+     *
+     * Leave it unset when attaching a volume: a volume is node-local, so the server
+     * places the sandbox in the volume's own region. Setting it to a region the volume
+     * is not in is rejected with a 400 rather than silently moved — that combination
+     * cannot be satisfied.
+     *
+     * Defaults to the platform's default sandbox region.
+     */
+    region?: string;
     /** Attach a persistent volume by id, mounted at `/data`. */
     volumeId?: string;
     /**
@@ -295,6 +311,27 @@ interface SandboxOpts extends ConnectionOpts {
      * Requires the sandbox's project to be given as an exact `projectId`.
      */
     volumeName?: string;
+    /**
+     * A `liz_` API key to write into the sandbox, so `lizard` works inside it. The CLI is
+     * preinstalled in every template; this is what authenticates it.
+     *
+     * The key must belong to the caller — the server verifies that and silently skips the
+     * injection otherwise.
+     *
+     * SECURITY: anything running in the sandbox can read this key, and sandboxes run
+     * untrusted code. Pass a WORKSPACE-SCOPED key rather than a full-access one. Scopes are
+     * enforced end to end, so a scoped key that escapes is bounded to that one workspace.
+     *
+     * @example
+     * ```ts
+     * const sandbox = await Sandbox.create('codex', {
+     *   projectId: 'proj_123',
+     *   lizardToken: process.env.LIZARD_WORKSPACE_KEY, // scoped to one workspace
+     * })
+     * await sandbox.process.exec('lizard volume list')
+     * ```
+     */
+    lizardToken?: string;
 }
 /**
  * Low-level HTTP client for the Lizard sandbox API.
@@ -317,13 +354,15 @@ declare class SandboxClient {
 }
 
 /**
- * A Lizard sandbox — an isolated Firecracker microVM that boots in milliseconds.
+ * A Lizard sandbox — an isolated Linux environment that starts in under a second.
+ *
+ * Each sandbox is a full Linux environment with its own filesystem, network, and
+ * process namespace, restored from a pre-warmed template snapshot.
  *
- * Each sandbox is a full Linux environment with its own filesystem, network,
- * and process namespace. Sandboxes are spun up from templates and can be
- * paused — vCPUs frozen, memory and running processes kept — then resumed
- * instantly, perfect for stateful AI agent sessions or ephemeral code
- * execution.
+ * Sandboxes are **ephemeral**: killing one, or letting it hit its timeout, discards
+ * everything written inside it. State that has to outlive a sandbox belongs on a
+ * {@link Volume}, which is a separate disk you mount at `/data` and re-attach to a
+ * later sandbox.
  *
  * @example Basic usage:
  * ```ts
@@ -336,16 +375,18 @@ declare class SandboxClient {
  * await sandbox.kill()
  * ```
  *
- * @example Pause and resume a long-running session:
+ * @example Carry work across sandboxes with a volume:
  * ```ts
- * const sandbox = await Sandbox.create('code-interpreter-v1', { project: 'my-project' })
- * await sandbox.process.exec('pip install numpy')
- * const id = sandbox.sandboxId
- * await sandbox.pause()
+ * const vol = await Volume.getOrCreate(projectId, 'agent-scratch', { sizeGb: 10 })
  *
- * // Later — resume exactly where it left off:
- * const resumed = await Sandbox.connect(id)
- * await resumed.process.exec('python -c "import numpy; print(numpy.__version__)"')
+ * const first = await Sandbox.create('codex', { projectId, volumeName: 'agent-scratch' })
+ * await first.process.exec('echo "notes" > /data/notes.txt')
+ * await first.kill()
+ *
+ * // A different sandbox, the same disk. No region to thread through: the sandbox
+ * // is placed wherever the volume already lives.
+ * const second = await Sandbox.create('codex', { projectId, volumeName: 'agent-scratch' })
+ * console.log(await second.fs.read('/data/notes.txt')) // "notes"
  * ```
  */
 declare class Sandbox extends SandboxClient {
@@ -406,8 +447,14 @@ declare class Sandbox extends SandboxClient {
     /**
      * Connect to an existing sandbox by its ID.
      *
-     * If the sandbox is currently paused, it will be automatically resumed
-     * before this call returns.
+     * Verifies the sandbox exists and is reachable, then returns a handle to it.
+     * Throws `NotFoundError` if it has been killed or has expired.
+     *
+     * This used to call `resume` first, on the assumption that a sandbox you are
+     * reconnecting to might be paused. Sandboxes are pods now and pause/resume is a
+     * `501` on every one of them, so that call turned every `connect()` into an
+     * error against a perfectly healthy sandbox. Connecting does not need to change
+     * a sandbox's state, so it no longer tries to.
      *
      * @example
      * ```ts
@@ -431,35 +478,21 @@ declare class Sandbox extends SandboxClient {
      */
     kill(opts?: ConnectionOpts): Promise<boolean>;
     /**
-     * Pause the sandbox microVM by freezing its vCPUs.
+     * Pause the sandbox by freezing it in place.
      *
-     * Memory, filesystem, and running processes are held in the host's RAM —
-     * nothing is written to disk, so a paused sandbox does not survive a host
-     * failure. Resume with `sandbox.resume()` or `Sandbox.connect(id)`.
-     *
-     * Pausing does not buy you time past the original deadline. Resuming pushes the
-     * expiry forward by however long the sandbox was paused — so a pause/resume cycle
-     * costs no runtime — but that adjustment only happens on `resume()`. A sandbox left
-     * paused past its original `expiresAt` is deleted there, within a minute, and
-     * `resume()` then returns `false`.
-     *
-     * In other words: pause and come back *before* the original deadline and you lose
-     * nothing; leave it paused across the deadline and it is gone. Pass `timeoutMs: 0`
-     * at create time to opt out of expiry entirely, which is the only way to park a
-     * sandbox indefinitely.
-     *
-     * @returns `true` if paused successfully.
+     * @deprecated Not implemented for the current runtime — always throws
+     * `LizardError` with HTTP 501. Sandboxes run as pods, and the equivalent is a CRIU
+     * checkpoint of the pod, which is not built. To park work across a gap, put it on a
+     * {@link Volume} and create a fresh sandbox on that volume later; the volume is the
+     * part that is meant to outlive a sandbox.
      */
     pause(opts?: ConnectionOpts): Promise<boolean>;
     /**
-     * Resume a paused sandbox by unfreezing its vCPUs.
-     *
-     * The expiry is pushed forward by the time spent paused, so the timeout measures
-     * running time rather than wall-clock — provided the original deadline had not
-     * already passed while paused. See {@link pause}.
+     * Resume a paused sandbox.
      *
-     * @returns `true` if resumed successfully, `false` if the sandbox no longer exists
-     * (including because it expired while paused).
+     * @deprecated Not implemented for the current runtime — always throws
+     * `LizardError` with HTTP 501. See {@link pause}. `Sandbox.connect()` no longer
+     * calls this, so reconnecting to a running sandbox works without it.
      */
     resume(opts?: ConnectionOpts): Promise<boolean>;
     /**
@@ -851,6 +884,304 @@ declare class MetricsAPI {
     all(id: string, range?: MetricRange): Promise<ServiceMetrics>;
 }
 
+interface Workspace {
+    id: string;
+    name: string;
+    slug: string;
+    /** `owner` | `admin` | `member` — the calling account's role in this workspace. */
+    role?: string;
+    /** True for the account's own workspace, which cannot be deleted. */
+    isPersonal?: boolean;
+    projectCount?: number;
+    plan?: string;
+    createdAt?: number | string;
+}
+interface CreateWorkspaceOpts {
+    name: string;
+}
+/**
+ * Workspaces — the top of the ownership tree: a workspace holds projects, a project
+ * holds services, sandboxes and volumes.
+ *
+ * This is the missing first step of per-user provisioning. Handing each of your users
+ * their own workspace, plus an API key scoped to it, is what keeps them isolated from
+ * one another while all of it bills to your account:
+ *
+ * ```ts
+ * const ws  = await lizard.workspaces.create({ name: `user-${userId}` })
+ * const prj = await lizard.projects.create({ workspaceId: ws.id, name: 'default' })
+ * const key = await lizard.apiKeys.create({ name: `user-${userId}`, workspaces: [ws.id] })
+ * // hand key.key to that user — it reaches nothing outside ws
+ * ```
+ *
+ * @see {@link ApiKeysAPI} for the scoping half of that flow.
+ */
+declare class WorkspacesAPI {
+    private readonly client;
+    constructor(client: PlatformClient);
+    /**
+     * List workspaces the calling credential can see.
+     *
+     * A scoped API key sees only what it is scoped to: a workspace-scoped key returns
+     * that one workspace, and a project-scoped key returns the workspace containing its
+     * project. A full key returns every workspace the account belongs to.
+     */
+    list(): Promise<Workspace[]>;
+    /** Create a workspace. The caller becomes its owner. */
+    create(opts: CreateWorkspaceOpts): Promise<Workspace>;
+    /**
+     * Delete a workspace.
+     *
+     * Empty-only by default — the server refuses while any project or sandbox remains,
+     * so this cannot quietly destroy a user's work. Pass `{ force: true }` to delete a
+     * workspace and everything in it; that is irreversible.
+     */
+    delete(id: string, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Find a workspace by name, slug, or id, or `null` if there is no such workspace.
+     * Matching is exact; id wins, then slug, then name.
+     */
+    find(nameOrSlugOrId: string): Promise<Workspace | null>;
+}
+
+interface ApiKeyScope {
+    type: 'workspace' | 'project';
+    id: string;
+    /** Present on read; the server resolves the scoped resource's name for display. */
+    name?: string;
+}
+interface ApiKey {
+    id: string;
+    name: string;
+    /** A masked fragment, e.g. `liz_abc…xyz`. The full key is only ever returned once. */
+    keyPreview?: string;
+    scopes: ApiKeyScope[];
+    createdAt?: number | string | null;
+    lastUsedAt?: number | string | null;
+}
+interface CreatedApiKey extends ApiKey {
+    /**
+     * The full `liz_` secret. **Returned exactly once, by this create call** — it is
+     * stored hashed and no later request can read it back. Hand it to its owner or
+     * persist it here, or it is gone.
+     */
+    key: string;
+}
+interface CreateApiKeyOpts {
+    name: string;
+    /** Workspace ids this key may reach. */
+    workspaces?: string[];
+    /** Project ids this key may reach. */
+    projects?: string[];
+    /** Raw scope list, if you would rather build it yourself than use the two above. */
+    scopes?: ApiKeyScope[];
+}
+/**
+ * API keys, including the scoped keys that make per-user isolation possible.
+ *
+ * **A key with no scope has full access** to every workspace and project the creating
+ * account can reach. Pass `workspaces` or `projects` to bound it. Scopes are enforced
+ * server-side on every route, so a scoped key that leaks — out of a sandbox, a log, a
+ * user's machine — reaches only what it was scoped to.
+ *
+ * A scoped key cannot mint a broader key: that check is server-side and exact, so
+ * handing a user a workspace-scoped key is not a step away from full access.
+ *
+ * @example Give each of your users their own isolated workspace
+ * ```ts
+ * const ws  = await lizard.workspaces.create({ name: `user-${userId}` })
+ * const prj = await lizard.projects.create({ workspaceId: ws.id, name: 'default' })
+ * const key = await lizard.apiKeys.create({ name: `user-${userId}`, workspaces: [ws.id] })
+ *
+ * // key.key is visible only here. Store it now.
+ * await db.users.update(userId, { lizardKey: key.key })
+ * ```
+ *
+ * @example Let a sandbox use the CLI as that user, and nothing more
+ * ```ts
+ * const sandbox = await Sandbox.create('codex', {
+ *   projectId: prj.id,
+ *   lizardToken: key.key, // scoped — safe to expose to code in the sandbox
+ * })
+ * await sandbox.process.exec('lizard volume list')
+ * ```
+ */
+declare class ApiKeysAPI {
+    private readonly client;
+    constructor(client: PlatformClient);
+    /** List the account's API keys. Previews only — full keys are never returned here. */
+    list(): Promise<ApiKey[]>;
+    /**
+     * Create an API key.
+     *
+     * The response is the only place the full key appears. Omitting every scope creates
+     * a full-access key; the server rejects an attempt to create one from a key that is
+     * itself scoped.
+     */
+    create(opts: CreateApiKeyOpts): Promise<CreatedApiKey>;
+    /** Revoke a key by id. It stops working immediately, everywhere. */
+    delete(id: string): Promise<void>;
+}
+
+interface Region {
+    id: string;
+    name?: string;
+    label?: string;
+    country?: string;
+    city?: string;
+    /** False for a region that exists but is not accepting new workloads. */
+    available?: boolean;
+    isDefault?: boolean;
+}
+/**
+ * The regions workloads can be placed in.
+ *
+ * Region ids are what `Sandbox.create({ region })` and `Volume.create({ region })`
+ * take, so this is how you discover a valid value rather than hardcoding one.
+ *
+ * @example
+ * ```ts
+ * const regions = await lizard.regions.list()
+ * console.log(regions.map(r => r.id)) // ['eu-west-lim-a', 'us-east-1', ...]
+ * ```
+ */
+declare class RegionsAPI {
+    private readonly client;
+    constructor(client: PlatformClient);
+    /** List every region, including ones not currently accepting workloads. */
+    list(): Promise<Region[]>;
+}
+
+interface Balance {
+    plan: string;
+    status: 'active' | 'grace' | 'frozen' | string;
+    /** Current balance in cents. Negative means the account is in debt. */
+    balanceCents: number;
+    overdraftLimitCents: number | null;
+    availableCents: number | null;
+    /** Current burn rate in cents per hour, across every running workload. */
+    hourlyRateCents: number;
+    /** Hours of runway left at the current rate, or `null` when nothing is running. */
+    runwayHours: number | null;
+    expiringCents: number;
+    expiringAt: number | null;
+    neverFreeze?: boolean;
+    invoicedMonthly?: boolean;
+    email?: string | null;
+}
+interface Transaction {
+    id: string;
+    kind: string;
+    amountCents: number;
+    balanceAfterCents?: number;
+    description?: string;
+    createdAt: number;
+}
+interface TransactionPage {
+    items: Transaction[];
+    nextCursor: string | null;
+}
+interface ListTransactionsOpts {
+    /** 1-100, default 20. */
+    limit?: number;
+    /** `nextCursor` from a previous page. */
+    cursor?: string;
+    /** Include the daily usage-deduction rows, which are otherwise omitted as noise. */
+    includeUsage?: boolean;
+}
+/**
+ * Account balance and usage.
+ *
+ * Billing is **account-scoped, not workspace-scoped**: every workspace you create for
+ * a user bills to the account that owns the key. That is what makes per-user
+ * workspaces a safe pattern — your users get isolation, you keep one bill — and also
+ * what makes {@link Balance.runwayHours} worth watching before you provision more.
+ */
+declare class BillingAPI {
+    private readonly client;
+    constructor(client: PlatformClient);
+    /** Current balance, status, burn rate, and runway. */
+    balance(): Promise<Balance>;
+    /** A page of balance transactions, newest first. */
+    transactions(opts?: ListTransactionsOpts): Promise<TransactionPage>;
+    /** Cost summary for the current billing period, broken down by resource. */
+    summary(): Promise<unknown>;
+    /** Live (not-yet-invoiced) usage accumulating right now. */
+    live(): Promise<unknown>;
+}
+
+interface VolumeInfo {
+    id: string;
+    projectId: string;
+    name: string;
+    sizeGb: number;
+    sizeMb?: number;
+    /** Region the volume's node lives in. A sandbox mounting it runs here too. */
+    region?: string;
+    status: string;
+    attachedTo?: string | null;
+    createdAt: number;
+}
+interface CreateVolumeOpts extends ConnectionOpts {
+    sizeGb?: number;
+    /**
+     * Region to place the volume in, e.g. `'us-east-1'`. A volume is node-local, so
+     * this also fixes where any sandbox mounting it must run — `Sandbox.create` takes
+     * the volume's region automatically when you don't name one, so you normally set
+     * the region here or nowhere.
+     *
+     * Defaults to the platform's default region.
+     */
+    region?: string;
+}
+/**
+ * A persistent volume that outlives sandboxes.
+ *
+ * A volume's **name** is its key inside a project: names are unique per project, and
+ * every method here accepts either a name or the generated id wherever a volume is
+ * addressed. Prefer the name — it is the thing you chose and can reconstruct, while
+ * the id only exists after the first create.
+ *
+ * Names are slugs: lowercase letters, digits and dashes, starting and ending with a
+ * letter or digit, up to 64 characters.
+ *
+ * Mount one to a sandbox via `Sandbox.create({ volumeName: 'my-data' })`.
+ */
+declare class Volume {
+    /** The volume's generated id. Stable, but you rarely need it — address by name. */
+    readonly volumeId: string;
+    /** The volume's name: unique within its project, and usable anywhere `volumeId` is. */
+    readonly name?: string;
+    private readonly config;
+    constructor(opts: {
+        volumeId: string;
+        name?: string;
+    } & ConnectionOpts);
+    /**
+     * Create a volume. Throws `ConflictError` (409) if the project already has one with
+     * this name — use {@link getOrCreate} when you want "make sure this exists" instead.
+     */
+    static create(projectId: string, name: string, opts?: CreateVolumeOpts): Promise<Volume>;
+    /**
+     * Return the project's volume with this name, creating it first if it does not
+     * exist yet. This is the reason a volume's name is its key: an agent that wants
+     * "the scratch disk for this task" no longer has to store an id between runs.
+     *
+     * An existing volume is returned as-is — `sizeGb` applies only to a fresh create
+     * and never resizes one that is already there.
+     */
+    static getOrCreate(projectId: string, name: string, opts?: CreateVolumeOpts): Promise<Volume>;
+    /** Look a volume up by name or by id. */
+    static get(projectId: string, nameOrId: string, opts?: ConnectionOpts): Promise<Volume>;
+    static list(projectId: string, opts?: ConnectionOpts): Promise<VolumeInfo[]>;
+    /** Delete a volume by name or by id, without constructing one first. */
+    static delete(projectId: string, nameOrId: string, opts?: ConnectionOpts): Promise<void>;
+    getInfo(projectId: string): Promise<VolumeInfo>;
+    delete(projectId: string): Promise<void>;
+}
+
 interface LizardOpts extends ConnectionOpts {
     /**
      * The project every sandbox created through this client belongs to — its ID,
@@ -892,6 +1223,14 @@ declare class Lizard {
     private readonly config;
     private readonly projectRef;
     private _platform;
+    /** Create, list and delete workspaces — the top of the ownership tree. */
+    readonly workspaces: WorkspacesAPI;
+    /** Mint and revoke API keys, including keys scoped to one workspace or project. */
+    readonly apiKeys: ApiKeysAPI;
+    /** List the regions workloads can be placed in. */
+    readonly regions: RegionsAPI;
+    /** Account balance, burn rate and transactions. */
+    readonly billing: BillingAPI;
     /** Manage projects. */
     readonly projects: ProjectsAPI;
     /** Deploy and manage services. */
@@ -913,10 +1252,51 @@ declare class Lizard {
      * @requires `project` to be set in the constructor.
      */
     create(template?: string, opts?: Omit<SandboxOpts, 'project' | 'projectId'>): Promise<Sandbox>;
-    /** Connect to an existing sandbox by ID (resumes it if paused). */
+    /** Connect to an existing sandbox by ID. Throws `NotFoundError` if it is gone. */
     connect(sandboxId: string, opts?: ConnectionOpts): Promise<Sandbox>;
     /** List running sandboxes for the authenticated account. */
     list(opts?: ConnectionOpts): Promise<SandboxInfo[]>;
+    /**
+     * Persistent volumes in this client's project.
+     *
+     * The same calls as the static {@link Volume} methods, minus the `projectId`
+     * argument — the client already knows it.
+     *
+     * @requires `project` to be set in the constructor.
+     *
+     * @example
+     * ```ts
+     * const lizard = new Lizard({ project: 'my-project' })
+     * const vol = await lizard.volumes.getOrCreate('scratch', { sizeGb: 10 })
+     * const sb  = await lizard.create('codex', { volumeName: 'scratch' })
+     * ```
+     */
+    readonly volumes: {
+        create: (name: string, opts?: CreateVolumeOpts) => Promise<Volume>;
+        getOrCreate: (name: string, opts?: CreateVolumeOpts) => Promise<Volume>;
+        get: (nameOrId: string, opts?: ConnectionOpts) => Promise<Volume>;
+        list: (opts?: ConnectionOpts) => Promise<VolumeInfo[]>;
+        delete: (nameOrId: string, opts?: ConnectionOpts) => Promise<void>;
+    };
+    /**
+     * The account this credential belongs to — the SDK's `lizard whoami`.
+     *
+     * Works for a scoped key as well as a full one: the identity is the account that
+     * created the key, which is what the key's usage bills to.
+     */
+    whoami(): Promise<Account>;
+    /** The underlying HTTP client, for endpoints this SDK does not wrap yet. */
+    get platform(): PlatformClient;
+}
+/** The account behind a credential — see {@link Lizard.whoami}. */
+interface Account {
+    id: string;
+    username: string;
+    email?: string | null;
+    avatarUrl?: string | null;
+    plan?: string;
+    billingStatus?: string;
+    balanceCents?: number;
 }
 
 /**
@@ -1099,63 +1479,4 @@ declare class CodeSandbox extends Sandbox {
     static connect(sandboxId: string, opts?: ConnectionOpts): Promise<CodeSandbox>;
 }
 
-interface VolumeInfo {
-    id: string;
-    projectId: string;
-    name: string;
-    sizeGb: number;
-    sizeMb?: number;
-    status: string;
-    attachedTo?: string | null;
-    createdAt: number;
-}
-interface CreateVolumeOpts extends ConnectionOpts {
-    sizeGb?: number;
-}
-/**
- * A persistent volume that outlives sandboxes.
- *
- * A volume's **name** is its key inside a project: names are unique per project, and
- * every method here accepts either a name or the generated id wherever a volume is
- * addressed. Prefer the name — it is the thing you chose and can reconstruct, while
- * the id only exists after the first create.
- *
- * Names are slugs: lowercase letters, digits and dashes, starting and ending with a
- * letter or digit, up to 64 characters.
- *
- * Mount one to a sandbox via `Sandbox.create({ volumeName: 'my-data' })`.
- */
-declare class Volume {
-    /** The volume's generated id. Stable, but you rarely need it — address by name. */
-    readonly volumeId: string;
-    /** The volume's name: unique within its project, and usable anywhere `volumeId` is. */
-    readonly name?: string;
-    private readonly config;
-    constructor(opts: {
-        volumeId: string;
-        name?: string;
-    } & ConnectionOpts);
-    /**
-     * Create a volume. Throws `ConflictError` (409) if the project already has one with
-     * this name — use {@link getOrCreate} when you want "make sure this exists" instead.
-     */
-    static create(projectId: string, name: string, opts?: CreateVolumeOpts): Promise<Volume>;
-    /**
-     * Return the project's volume with this name, creating it first if it does not
-     * exist yet. This is the reason a volume's name is its key: an agent that wants
-     * "the scratch disk for this task" no longer has to store an id between runs.
-     *
-     * An existing volume is returned as-is — `sizeGb` applies only to a fresh create
-     * and never resizes one that is already there.
-     */
-    static getOrCreate(projectId: string, name: string, opts?: CreateVolumeOpts): Promise<Volume>;
-    /** Look a volume up by name or by id. */
-    static get(projectId: string, nameOrId: string, opts?: ConnectionOpts): Promise<Volume>;
-    static list(projectId: string, opts?: ConnectionOpts): Promise<VolumeInfo[]>;
-    /** Delete a volume by name or by id, without constructing one first. */
-    static delete(projectId: string, nameOrId: string, opts?: ConnectionOpts): Promise<void>;
-    getInfo(projectId: string): Promise<VolumeInfo>;
-    delete(projectId: string): Promise<void>;
-}
-
-export { type Addon, type AddonType, AuthenticationError, type CodeContext, CodeSandbox, ConflictError, type ConnectionOpts, type CostMetrics, type CreateAddonOpts, type CreateContextOpts, type CreateProjectOpts, type CreateServiceOpts, type CreateVolumeOpts, type DeployEvent, DeployHandle, type DomainInfo, Execution, ExecutionError, type FileInfo, type FsOpts, Lizard, LizardError, type LizardOpts, type LogLine, type MetricPoint, type MetricRange, NotFoundError, type ProcessOpts, type ProcessResult, type Project, type RunCodeLanguage, type RunCodeOpts, Sandbox, type SandboxInfo, type SandboxOpts, type ScaleOpts, type Secret, type Service, type ServiceMetrics, type SetSecretOpts, TimeoutError, Volume, type VolumeInfo, resolveProjectId };
+export { type Account, type Addon, type AddonType, AddonsAPI, type ApiKey, type ApiKeyScope, ApiKeysAPI, AuthenticationError, type Balance, BillingAPI, type CodeContext, CodeSandbox, ConflictError, type ConnectionOpts, type CostMetrics, type CreateAddonOpts, type CreateApiKeyOpts, type CreateContextOpts, type CreateProjectOpts, type CreateServiceOpts, type CreateVolumeOpts, type CreateWorkspaceOpts, type CreatedApiKey, type DeployEvent, DeployHandle, type DomainInfo, DomainsAPI, Execution, ExecutionError, type FileInfo, type FsOpts, type ListTransactionsOpts, Lizard, LizardError, type LizardOpts, type LogLine, type MetricPoint, type MetricRange, MetricsAPI, NotFoundError, PlatformClient, type ProcessOpts, type ProcessResult, type Project, ProjectsAPI, type Region, RegionsAPI, type RunCodeLanguage, type RunCodeOpts, Sandbox, type SandboxInfo, type SandboxOpts, type ScaleOpts, type Secret, SecretsAPI, type Service, type ServiceMetrics, ServicesAPI, type SetSecretOpts, TimeoutError, type Transaction, type TransactionPage, Volume, type VolumeInfo, type Workspace, WorkspacesAPI, resolveProjectId };