palbase 0.0.0-stage → 0.1.0

package/types/internal/src/modules/machines.d.ts

@@ -0,0 +1,1584 @@
+import { type Reply, type Transport } from '../transport.js';
+/**
+ * One build of a machine: one commit of its branch, built once however often it is pushed.
+ */
+export type Build = {
+    id: string;
+    commit: string;
+    /**
+     * The commit's message, its first 1000 bytes.
+     */
+    message: string;
+    /**
+     * waiting_checks: its machine builds a commit once its checks have passed (`deploy_after_checks`), and `reason` says what it waits for — several builds of a machine wait at once, each for its own commit's checks; queued; building; testing: released to its machine, its tests (`test_command`) running against it before it takes traffic — they fail and it fails (`reason` names the tests), the machine running what it ran; waiting_config: built, waiting for what its .env.example names (`missing_env`) — it rolls out once the machine has it; succeeded: built and rolled out (or a newer build already had); failed (`reason`); cancelled: a newer commit was built (its checks passed first, or its machine does not wait for them), the head of the machine's branch was asked for (a deploy, or a change of source, leaves the builds waiting for other commits' checks behind), or the machine was deleted (`reason`); skipped: its commit's checks did not pass, none was reported, named ones were cancelled before they ran or not reported, or they did not end in time (`reason`) — nothing of it was built.
+     */
+    state: "building" | "cancelled" | "failed" | "queued" | "skipped" | "succeeded" | "testing" | "waiting_checks" | "waiting_config";
+    reason?: string;
+    /**
+     * What the build's .env.example names that the machine's env and secrets do not hold.
+     */
+    missing_env: string[];
+    /**
+     * The machine runs this build, or rolls out to it.
+     */
+    running: boolean;
+    /**
+     * The machine may return to this build (POST /machines/{name}/rollback): it succeeded and its image is kept — a machine keeps the images of ten of its builds that succeeded, the one it runs among them.
+     */
+    returnable: boolean;
+    created_at: string;
+    started_at?: string;
+    finished_at?: string;
+};
+/**
+ * A page of a machine's builds, newest first.
+ */
+export type BuildPage = {
+    builds: Build[];
+    /**
+     * The cursor of the next page; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * The build a machine runs, or rolls out to.
+ */
+export type BuildRef = {
+    id: string;
+    commit: string;
+};
+/**
+ * Where the project's owner goes to connect GitHub. GitHub asks who they are and comes back to the platform, which shows them the accounts Palbase Cloud is installed on that they can push to — and where to install it on another — and connects the one they choose once they write the project's ref.
+ */
+export type Connect = {
+    url: string;
+    expires_at: string;
+    /**
+     * The App's OAuth client id: public, every link to GitHub's sign-in names it. A device with no browser (the CLI) signs its user in to the App with it by GitHub's device flow and links an installation with the token (POST /machines/github/installations).
+     */
+    client_id: string;
+};
+export type ErrorResponse = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Human-readable explanation
+     */
+    error_description: string;
+    /**
+     * Correlation ID for log/audit lookup
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying; present on a refusal that ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code (mirrors the response status)
+     */
+    status: number;
+};
+/**
+ * One of the project's installations of Palbase Cloud, the platform's GitHub App.
+ */
+export type Installation = {
+    installation_id: number;
+    /**
+     * The GitHub account it is installed on.
+     */
+    account: string;
+    /**
+     * The GitHub user who connected it: the project reaches the repositories of it that user could push to when they connected it.
+     */
+    linked_by: string;
+    created_at: string;
+};
+/**
+ * Connects an installation the user reaches — a CLI's way, with the user's own GitHub token for Palbase Cloud (its device flow). The token proves the user may reach the installation and is kept nowhere.
+ */
+export type InstallationLink = {
+    installation_id: number;
+    user_token: string;
+};
+/**
+ * The project's installations.
+ */
+export type InstallationList = {
+    installations: Installation[];
+};
+/**
+ * A project's machine: what was asked for, and what runs.
+ */
+export type Machine = {
+    created_at: string;
+    /**
+     * The machine's name; `backend` is the project's backend.
+     */
+    name: string;
+    /**
+     * The TCP port the machine listens on; requests to its address are sent there. The machine also finds it in PORT. A change of it rolls out as any change does: while both versions serve, each is sent requests at its own port.
+     */
+    port: number;
+    /**
+     * The version the machine runs; it equals `version` once a change has rolled out. A change of how it runs (not a new build, which the machine returns from to the build it served) whose version did not come up within the 5 minutes a rollout has, while the one before served, is given up on: the machine runs the one before, which serves on, sleeps when idle and is what a request wakes, until its next change rolls out a new version (`state_reason` says why). 0 before it has run.
+     */
+    running_version: number;
+    /**
+     * The machine's size. A shared size has a fraction of a CPU as its ceiling and is put to sleep when it is idle; a dedicated size has whole CPUs of its own and never sleeps. shared-256: 0.2 vCPU, 256 MiB; shared-512: 0.5 vCPU, 512 MiB; shared-1024: 1 vCPU, 1024 MiB; dedicated-1x: 1 vCPU, 2048 MiB; dedicated-2x: 2 vCPU, 4096 MiB.
+     */
+    size: "dedicated-1x" | "dedicated-2x" | "shared-1024" | "shared-256" | "shared-512";
+    /**
+     * building: no build of it runs yet (its first is on its way — waiting for its commit's checks too — or failed: `state_reason`); starting: on its way up; awake: answering; asleep: idle, and woken by the next request to its address; failed: it cannot start, or its first build failed or was skipped (`state_reason` says why).
+     */
+    state: "asleep" | "awake" | "building" | "failed" | "starting";
+    /**
+     * Why the machine has failed, or why a new version is not up — its image could not be pulled, it could not be started, its process keeps exiting or ran out of its memory, it does not answer 2xx at its health path (it is started again each time it has not in the 90 s it has), nothing answers on its port (past 90 s) — or that a version did not come up and the one before runs; absent otherwise.
+     */
+    state_reason?: string;
+    updated_at: string;
+    /**
+     * Where the machine answers: the project's own address for `backend`, <name>-<ref> under the app domain for any other.
+     */
+    url: string;
+    /**
+     * Counts the changes asked for, from 1.
+     */
+    version: number;
+    /**
+     * What the machine is started with in its environment, besides what the platform sets: PORT, PALBASE_URL (its project's address), PALBASE_PROJECT_ID, PALBASE_REPLICAS and, given a database, PALBASE_DB_URL and PALBASE_DB_CONNECTIONS.
+     */
+    env: {
+        [key: string]: string;
+    };
+    /**
+     * The project's secret environment the machine is started with; absent when none.
+     */
+    secrets?: "production" | "development";
+    source: Source;
+    build?: BuildRef;
+    /**
+     * A build of the branch's head is asked for — opened, pushed to, deployed, its source changed — and not queued yet: the platform asks GitHub for the head first. Once false, the machine's newest build is the one asked for, or, when the branch was not found, `state` and `state_reason` say so.
+     */
+    build_requested: boolean;
+    /**
+     * Where the machine says it is well, as asked of it (MachineCreate.health_path); absent when its build says.
+     */
+    health_path?: string;
+    /**
+     * How many copies of the machine run while it is awake, each on a node of its own: a request is sent to one of them, a copy or a node that goes leaves the others serving, and the cluster takes one of them away at a time at most. Every copy is of the machine's size and counts as such against the project's limits and its machine time (a minute in which the number changed is counted at the most it was). What a copy keeps in its own memory or on its own disk the others do not see — a session, a counter, a cache, a timer: a machine with more than one keeps those where every copy reaches them. The machine finds the number in PALBASE_REPLICAS. A long-lived connection (a WebSocket) stays with the copy that took it.
+     */
+    replicas: number;
+    database?: MachineDatabase;
+    /**
+     * Whether a push waits for its commit's checks before it is built; absent when it does not. A push is built only once its commit's checks on GitHub have passed, as Render's "After CI Checks Pass": those `deploy_checks` names, or else every check run reported on the commit for the machine's branch (GitHub Actions' jobs, and any other app's checks; Palbase's own left out) has ended in success, neutral or skipped, and every GitHub Actions workflow run of it has ended — taken as ended 30 s after the last ended, and no sooner than 30 s after the push's build was made. Until then the build waits (`waiting_checks`, its `reason` naming what it waits for), and the machine runs what it ran; a newer push waits beside it, for its own. The machine moves to the newest commit whose checks passed, never back: the first to pass is built and leaves the older builds behind, waiting or under way, so an older commit whose checks pass after it is not built. A check that ended otherwise (failure, cancelled, timed_out, action_required, stale), no check reported in 10 minutes, or checks not ended in 3 hours (6 hours for named ones), and the build is `skipped` (`reason`); a check run again that passes later does not build it — the next push to the branch is built then, whatever it changed. Commit statuses are not read.
+     */
+    deploy_after_checks?: boolean;
+    /**
+     * The check runs a push waits for (`deploy_after_checks`) instead of every check, by their names as GitHub shows them — a GitHub Actions job's name, e.g. `unit` — from the app `deploy_checks_app` names, on the commit's suites for the machine's branch (a run of the same commit from a tag or another branch does not count, nor another app's run of that name): each is to be reported, to end and to succeed (success or neutral: a named check skipped did not run) — every run of that name, when two workflows name a job alike. While a suite of that app is open on the branch, with runs or not yet, the push waits. No other check is waited for or looked at. A named check that ends otherwise, or that the app's suites on the branch all ended without (cancelled before they ran), and the build is `skipped` at once (`reason`); one not reported in 6 hours, too. 20 names at most, each 1 to 200 characters with no space around it, named once. Absent: every check is waited for.
+     */
+    deploy_checks?: string[];
+    /**
+     * The app named checks (`deploy_checks`) are taken from, by its GitHub App slug — as a required check's expected source is: another app's run of a named check counts for nothing.
+     */
+    deploy_checks_app?: string;
+    /**
+     * What each new build of the machine runs before it takes traffic (Render's pre-deploy command, a CI's test step): once its database's migration has started, the new version comes up beside the one that serves — its own env, secrets and database — and its image runs this command in a shell (so the image has one) against it: `PALBASE_TEST_BASE_URL` is where it answers, `PALBASE_TEST_AUTH_URL` the project's auth. The tests reach what the machine reaches — its database, the project's modules — so they write as it does. They end other than 0 and the build fails, its `reason` naming the tests that failed: the version never takes traffic, the machine runs what it ran, and the migration is taken back. `bun test`, `npm test`. A build is tested as the machine says when it is released. Absent, a build rolls out once built.
+     */
+    test_command?: string;
+    /**
+     * The project's test users each test run makes for its tests to act as — `PALBASE_TEST_IDENTITIES` names them, each with its access token (`api.signInAs("alice")`) — and deletes once the run has ended, however it ended. Each a name, once whatever its case: letters, digits, `_` and `-`, 64 at most.
+     */
+    test_users?: string[];
+    /**
+     * Where an app that is not a palbase/backend one serves its contract (OpenAPI), read once a build's version alone serves the machine. Absent for a palbase/backend app, whose build writes it.
+     */
+    openapi_path?: string;
+    /**
+     * The SHA-256 (hex) of the contract the build the machine serves from says it answers (GET /machines/{name}/openapi): a client generated from it is current while the two are the same. Absent while the contract has not been read, or when the app serves none.
+     */
+    contract_digest?: string;
+};
+/**
+ * A machine to open.
+ */
+export type MachineCreate = {
+    /**
+     * The machine's name; `backend`, the project's backend, when left out. Not `github`.
+     */
+    name?: string;
+    /**
+     * The TCP port the machine listens on; requests to its address are sent there. The machine also finds it in PORT. A change of it rolls out as any change does: while both versions serve, each is sent requests at its own port.
+     */
+    port?: number;
+    /**
+     * The machine's size. A shared size has a fraction of a CPU as its ceiling and is put to sleep when it is idle; a dedicated size has whole CPUs of its own and never sleeps. shared-256: 0.2 vCPU, 256 MiB; shared-512: 0.5 vCPU, 512 MiB; shared-1024: 1 vCPU, 1024 MiB; dedicated-1x: 1 vCPU, 2048 MiB; dedicated-2x: 2 vCPU, 4096 MiB.
+     */
+    size: "dedicated-1x" | "dedicated-2x" | "shared-1024" | "shared-256" | "shared-512";
+    /**
+     * What the machine is started with in its environment, besides what the platform sets: PORT (where it listens), PALBASE_URL (its project's address, https://<ref>.<domain>), PALBASE_PROJECT_ID, PALBASE_REPLICAS (how many copies of it run) and, given a database, PALBASE_DB_URL and PALBASE_DB_CONNECTIONS (how many connections to it a copy may hold). PORT is refused here; the others, given here or among the machine's secrets, give way to the platform's. Names are environment variable names; 100 variables and 64 KiB at most. Keep secrets in the project's secrets and start the machine with them (`secrets`).
+     */
+    env?: {
+        [key: string]: string;
+    };
+    /**
+     * The project's secret environment the machine is started with: each of its secrets is in the machine's environment by name. A name in `env` wins over the same secret. When a secret of it changes, the machine rolls out with the new value beside the version that serves. Empty: none.
+     */
+    secrets?: "" | "production" | "development";
+    source: Source;
+    /**
+     * Where the machine says it is well, as asked of it: a path from the root on its port (200 characters at most, no query) that answers 2xx while it serves. While it starts it has 90 s to answer there; once it serves, one that stops answering there for about 6 s is started again. Empty, its build says: a Palbase backend's (palbase/backend) is /_palbase/health; a machine that says nowhere is asked only whether it listens on its port.
+     */
+    health_path?: string;
+    /**
+     * How many copies of the machine run while it is awake, each on a node of its own: a request is sent to one of them, a copy or a node that goes leaves the others serving, and the cluster takes one of them away at a time at most. Every copy is of the machine's size and counts as such against the project's limits and its machine time (a minute in which the number changed is counted at the most it was). What a copy keeps in its own memory or on its own disk the others do not see — a session, a counter, a cache, a timer: a machine with more than one keeps those where every copy reaches them. The machine finds the number in PALBASE_REPLICAS. A long-lived connection (a WebSocket) stays with the copy that took it. One when left out.
+     */
+    replicas?: number;
+    database?: MachineDatabase;
+    /**
+     * A push is built only once its commit's checks on GitHub have passed, as Render's "After CI Checks Pass": those `deploy_checks` names, or else every check run reported on the commit for the machine's branch (GitHub Actions' jobs, and any other app's checks; Palbase's own left out) has ended in success, neutral or skipped, and every GitHub Actions workflow run of it has ended — taken as ended 30 s after the last ended, and no sooner than 30 s after the push's build was made. Until then the build waits (`waiting_checks`, its `reason` naming what it waits for), and the machine runs what it ran; a newer push waits beside it, for its own. The machine moves to the newest commit whose checks passed, never back: the first to pass is built and leaves the older builds behind, waiting or under way, so an older commit whose checks pass after it is not built. A check that ended otherwise (failure, cancelled, timed_out, action_required, stale), no check reported in 10 minutes, or checks not ended in 3 hours (6 hours for named ones), and the build is `skipped` (`reason`); a check run again that passes later does not build it — the next push to the branch is built then, whatever it changed. Commit statuses are not read. False: every push is built at once.
+     */
+    deploy_after_checks?: boolean;
+    /**
+     * The check runs a push waits for (`deploy_after_checks`) instead of every check, by their names as GitHub shows them — a GitHub Actions job's name, e.g. `unit` — from the app `deploy_checks_app` names, on the commit's suites for the machine's branch (a run of the same commit from a tag or another branch does not count, nor another app's run of that name): each is to be reported, to end and to succeed (success or neutral: a named check skipped did not run) — every run of that name, when two workflows name a job alike. While a suite of that app is open on the branch, with runs or not yet, the push waits. No other check is waited for or looked at. A named check that ends otherwise, or that the app's suites on the branch all ended without (cancelled before they ran), and the build is `skipped` at once (`reason`); one not reported in 6 hours, too. 20 names at most, each 1 to 200 characters with no space around it, named once. Empty: every check is waited for.
+     */
+    deploy_checks?: string[];
+    /**
+     * The app named checks (`deploy_checks`) are taken from, by its GitHub App slug — as a required check's expected source is: another app's run of a named check counts for nothing. Empty or left out: github-actions.
+     */
+    deploy_checks_app?: string;
+    /**
+     * What each new build of the machine runs before it takes traffic (Render's pre-deploy command, a CI's test step): once its database's migration has started, the new version comes up beside the one that serves — its own env, secrets and database — and its image runs this command in a shell (so the image has one) against it: `PALBASE_TEST_BASE_URL` is where it answers, `PALBASE_TEST_AUTH_URL` the project's auth. The tests reach what the machine reaches — its database, the project's modules — so they write as it does. They end other than 0 and the build fails, its `reason` naming the tests that failed: the version never takes traffic, the machine runs what it ran, and the migration is taken back. `bun test`, `npm test`. A build is tested as the machine says when it is released. Absent, a build rolls out once built.
+     */
+    test_command?: string;
+    /**
+     * The project's test users each test run makes for its tests to act as — `PALBASE_TEST_IDENTITIES` names them, each with its access token (`api.signInAs("alice")`) — and deletes once the run has ended, however it ended. Each a name, once whatever its case: letters, digits, `_` and `-`, 64 at most.
+     */
+    test_users?: string[];
+    /**
+     * Where the machine's app serves its contract when it is not a palbase/backend app. Empty (the default) for a palbase/backend app.
+     */
+    openapi_path?: string;
+};
+/**
+ * A page of a project's machines, by name.
+ */
+export type MachinePage = {
+    machines: Machine[];
+    /**
+     * The cursor of the next page; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * The OpenAPI document a machine's app serves of itself, as it served it: a JSON object of the app's own.
+ */
+export type MachineContract = {
+    [key: string]: unknown;
+};
+/**
+ * What to change; a field left out stays as it is. A new source is built, and rolls out once its build is up; a new size, port, env or secrets rolls out beside what serves.
+ */
+export type MachineUpdate = {
+    /**
+     * The TCP port the machine listens on; requests to its address are sent there. The machine also finds it in PORT. A change of it rolls out as any change does: while both versions serve, each is sent requests at its own port.
+     */
+    port?: number;
+    /**
+     * The machine's size. A shared size has a fraction of a CPU as its ceiling and is put to sleep when it is idle; a dedicated size has whole CPUs of its own and never sleeps. shared-256: 0.2 vCPU, 256 MiB; shared-512: 0.5 vCPU, 512 MiB; shared-1024: 1 vCPU, 1024 MiB; dedicated-1x: 1 vCPU, 2048 MiB; dedicated-2x: 2 vCPU, 4096 MiB.
+     */
+    size?: "dedicated-1x" | "dedicated-2x" | "shared-1024" | "shared-256" | "shared-512";
+    /**
+     * Replaces the machine's environment whole, besides PORT. Names are environment variable names; 100 variables and 64 KiB at most. Keep secrets in the project's secrets and start the machine with them (`secrets`).
+     */
+    env?: {
+        [key: string]: string;
+    };
+    /**
+     * The project's secret environment the machine is started with; empty for none.
+     */
+    secrets?: "" | "production" | "development";
+    source?: Source;
+    /**
+     * A new health path: the machine rolls out with it. Empty lets its build say.
+     */
+    health_path?: string;
+    /**
+     * How many copies of the machine run from now on: the machine rolls out as a new version with that many, beside what serves.
+     */
+    replicas?: number;
+    database?: MachineDatabase;
+    /**
+     * Whether a push waits for its commit's checks from now on; no version is rolled out for it. The newest build waiting for its checks when it is turned off is built at once, and the older ones are left behind. A push is built only once its commit's checks on GitHub have passed, as Render's "After CI Checks Pass": those `deploy_checks` names, or else every check run reported on the commit for the machine's branch (GitHub Actions' jobs, and any other app's checks; Palbase's own left out) has ended in success, neutral or skipped, and every GitHub Actions workflow run of it has ended — taken as ended 30 s after the last ended, and no sooner than 30 s after the push's build was made. Until then the build waits (`waiting_checks`, its `reason` naming what it waits for), and the machine runs what it ran; a newer push waits beside it, for its own. The machine moves to the newest commit whose checks passed, never back: the first to pass is built and leaves the older builds behind, waiting or under way, so an older commit whose checks pass after it is not built. A check that ended otherwise (failure, cancelled, timed_out, action_required, stale), no check reported in 10 minutes, or checks not ended in 3 hours (6 hours for named ones), and the build is `skipped` (`reason`); a check run again that passes later does not build it — the next push to the branch is built then, whatever it changed. Commit statuses are not read.
+     */
+    deploy_after_checks?: boolean;
+    /**
+     * The check runs a push waits for (`deploy_after_checks`) instead of every check, by their names as GitHub shows them — a GitHub Actions job's name, e.g. `unit` — from the app `deploy_checks_app` names, on the commit's suites for the machine's branch (a run of the same commit from a tag or another branch does not count, nor another app's run of that name): each is to be reported, to end and to succeed (success or neutral: a named check skipped did not run) — every run of that name, when two workflows name a job alike. While a suite of that app is open on the branch, with runs or not yet, the push waits. No other check is waited for or looked at. A named check that ends otherwise, or that the app's suites on the branch all ended without (cancelled before they ran), and the build is `skipped` at once (`reason`); one not reported in 6 hours, too. 20 names at most, each 1 to 200 characters with no space around it, named once. Replaces the names whole; empty waits for every check again. No version is rolled out for it.
+     */
+    deploy_checks?: string[];
+    /**
+     * The app named checks (`deploy_checks`) are taken from, by its GitHub App slug — as a required check's expected source is: another app's run of a named check counts for nothing. No version is rolled out for it.
+     */
+    deploy_checks_app?: string;
+    /**
+     * What each new build of the machine runs before it takes traffic (Render's pre-deploy command, a CI's test step): once its database's migration has started, the new version comes up beside the one that serves — its own env, secrets and database — and its image runs this command in a shell (so the image has one) against it: `PALBASE_TEST_BASE_URL` is where it answers, `PALBASE_TEST_AUTH_URL` the project's auth. The tests reach what the machine reaches — its database, the project's modules — so they write as it does. They end other than 0 and the build fails, its `reason` naming the tests that failed: the version never takes traffic, the machine runs what it ran, and the migration is taken back. `bun test`, `npm test`. A build is tested as the machine says when it is released. Absent, a build rolls out once built. An empty string runs none from now on.
+     */
+    test_command?: string;
+    /**
+     * The project's test users each test run makes for its tests to act as — `PALBASE_TEST_IDENTITIES` names them, each with its access token (`api.signInAs("alice")`) — and deletes once the run has ended, however it ended. Each a name, once whatever its case: letters, digits, `_` and `-`, 64 at most.
+     */
+    test_users?: string[];
+    /**
+     * Where the machine's app serves its contract from now on: nothing that runs changes, and the contract of the build it serves from is read again. Empty for a palbase/backend app.
+     */
+    openapi_path?: string;
+};
+/**
+ * A repository a machine may be built from.
+ */
+export type RepositoryEntry = {
+    repository: string;
+    installation_id: number;
+    private: boolean;
+    default_branch: string;
+};
+/**
+ * Every repository the project's installations reach.
+ */
+export type RepositoryList = {
+    repositories: RepositoryEntry[];
+};
+/**
+ * One of the machine's builds that succeeded.
+ */
+export type Rollback = {
+    build: string;
+};
+/**
+ * Where a machine is built from: a branch of a GitHub repository one of the project's installations of Palbase Cloud reaches (GET /machines/github/repositories), and a directory of it. A push to the branch is built — the directory's Dockerfile, or, without one, what Railpack detects (Node, Go, Python, …) — and rolled out when it changes a file in what the build is given: its context (`context`, else `path`), matched by whole directory names, case-sensitively; a push that changes nothing there leaves the machine as it runs, and does not count against the project's builds for the day. A machine built from the repository's root is built by every push. When what GitHub names of a push may not be all it changed — a forced push, a branch's first push, a push of 2048 commits or more, a commit naming no files (an empty commit among them) or 3000 or more — every machine built from the branch is built.
+ */
+export type Source = {
+    /**
+     * The repository's full name: owner/name.
+     */
+    repository: string;
+    /**
+     * The branch whose pushes are built and rolled out: those that change what the machine is built from.
+     */
+    branch: string;
+    /**
+     * The directory the machine is built from, relative to the repository's root; the root when left out. Its Dockerfile, when it has one, its package.json and its .env.example are read here.
+     */
+    path?: string;
+    /**
+     * What the build is given as its context, when that is not `path` itself: a directory above `path`, or `.` for the repository's root. An app of a workspace (a monorepo) that needs its sibling packages is built with them in reach: its Dockerfile, in `path`, copies from the context; without a Dockerfile, Railpack plans the context. Left out, the context is `path`.
+     */
+    context?: string;
+};
+/**
+ * A project's database: what was asked for, and what runs.
+ */
+export type Database = {
+    /**
+     * The database's name.
+     */
+    name: string;
+    /**
+     * Where it answers: <name>-<ref>.<the databases' domain>.
+     */
+    host: string;
+    /**
+     * Its port straight to Postgres.
+     */
+    port: number;
+    /**
+     * Its port through PgBouncer (transaction pooling): for clients that open a connection for each request.
+     */
+    pooled_port: number;
+    /**
+     * The database's size. free: 0.25 vCPU, 512 MiB, 1 GB, put to sleep when idle (woken by the next connection in about 10 s), awake 400 hours a month at most, archived after a week asleep (its next connection brings it back from its backup); hobby: 0.25 vCPU, 512 MiB, 5 GB, put to sleep when idle, no monthly limit; shared-1g: 1 GiB, up to 1 vCPU, 10 GB; shared-2g: 2 GiB, up to 2 vCPU, 25 GB; shared-4g: 4 GiB, up to 2 vCPU, 50 GB; dedicated-1x: 1 vCPU of its own, 4 GiB, 25 GB; dedicated-2x: 2 vCPU of its own, 8 GiB, 50 GB. The shared and dedicated sizes never sleep and live on a Premium SSD v2 disk of their own; free and hobby on the platform's SAN. A database past its size's storage turns read-only. What a project's machines and databases reserve between them is held to its limit: a size that does not fit is refused (409 `machines_over_limit`).
+     */
+    size: "dedicated-1x" | "dedicated-2x" | "free" | "hobby" | "shared-1g" | "shared-2g" | "shared-4g";
+    /**
+     * Where its data lives, as its size says: san, the platform's SAN; premium, a Premium SSD v2 disk of its own.
+     */
+    disk: "premium" | "san";
+    /**
+     * Who may connect, as addresses or CIDRs (203.0.113.7, 203.0.113.0/24), 50 at most; anyone with the password when empty.
+     */
+    allow: string[];
+    /**
+     * How many days the database's backups are kept: it can be brought back to any moment of them. 1 to 35.
+     */
+    backup_days: number;
+    /**
+     * starting: on its way up; awake: answering; asleep: idle, woken by the next connection; archived: asleep for a week, its next connection brings it back from its backup; restoring: being brought back to a moment of its backups; resizing: moving to its size (`size`, the one asked for) through an instance of that size beside the one that serves — it serves on; its sessions on the direct port end once, as its primary moves to the new instance, and so does a transaction under way at that moment; new logins and transactions wait a few seconds for it; failed: it cannot start (`state_reason` says why) — a restore could not bring it back, even to the latest moment of its backups; another restore may be asked for.
+     */
+    state: "archived" | "asleep" | "awake" | "failed" | "resizing" | "restoring" | "starting";
+    /**
+     * Why it is in its state, when that needs saying.
+     */
+    state_reason?: string;
+    /**
+     * When it was deleted; it may be taken back until `purge_after`.
+     */
+    deleted_at?: string;
+    /**
+     * When a deleted database, its volume and its backups are gone for good.
+     */
+    purge_after?: string;
+    created_at: string;
+    updated_at: string;
+    /**
+     * How long it has run this month, in hours.
+     */
+    awake_hours?: number;
+    /**
+     * How long its size lets it run in a month, in hours: past it, it sleeps until the month ends, and a client is told so. Absent for a size with no such limit.
+     */
+    awake_hours_limit?: number;
+    /**
+     * How much it held when last measured — every database in it summed, the ones its owner made too — measured while it is awake. Absent before its first measure.
+     */
+    used_bytes?: number;
+    /**
+     * The most its size holds. Past it, it is read-only.
+     */
+    quota_bytes: number;
+    /**
+     * It holds its quota: a transaction takes no writes unless it asks to — BEGIN READ WRITE, to make room with DROP, TRUNCATE, or DELETE and then VACUUM FULL (a DELETE alone frees no room) — and it reads on. Once it holds less than 95% of its quota it takes writes again, within a minute.
+     */
+    read_only: boolean;
+    /**
+     * A change of its passwords (POST …/password) has not reached the database yet: the new password works once this is false, a few seconds after. A client that hands the new password on waits for it.
+     */
+    password_changing: boolean;
+    /**
+     * What it has read from and written to its disk this month: its SAN volume's traffic, counted every minute from its node's device. Absent for a size on a premium disk, whose traffic is not counted.
+     */
+    traffic_bytes?: number;
+    /**
+     * How much its size lets it read from and write to its disk in a month: past it, it sleeps until the month ends, and a client is told so. Absent for a size with no such limit.
+     */
+    traffic_limit_bytes?: number;
+};
+/**
+ * A page of a project's databases, by name.
+ */
+export type DatabasePage = {
+    databases: Database[];
+    /**
+     * The cursor of the next page; absent on the last page.
+     */
+    next_cursor?: string;
+};
+/**
+ * A database to open.
+ */
+export type DatabaseCreate = {
+    /**
+     * The database's name; `main` when left out.
+     */
+    name?: string;
+    /**
+     * The database's size; `free` when left out. free: 0.25 vCPU, 512 MiB, 1 GB, put to sleep when idle (woken by the next connection in about 10 s), awake 400 hours a month at most, archived after a week asleep (its next connection brings it back from its backup); hobby: 0.25 vCPU, 512 MiB, 5 GB, put to sleep when idle, no monthly limit; shared-1g: 1 GiB, up to 1 vCPU, 10 GB; shared-2g: 2 GiB, up to 2 vCPU, 25 GB; shared-4g: 4 GiB, up to 2 vCPU, 50 GB; dedicated-1x: 1 vCPU of its own, 4 GiB, 25 GB; dedicated-2x: 2 vCPU of its own, 8 GiB, 50 GB. The shared and dedicated sizes never sleep and live on a Premium SSD v2 disk of their own; free and hobby on the platform's SAN. A database past its size's storage turns read-only. What a project's machines and databases reserve between them is held to its limit: a size that does not fit is refused (409 `machines_over_limit`).
+     */
+    size?: "dedicated-1x" | "dedicated-2x" | "free" | "hobby" | "shared-1g" | "shared-2g" | "shared-4g";
+    /**
+     * Who may connect, as addresses or CIDRs (203.0.113.7, 203.0.113.0/24), 50 at most; anyone with the password when empty.
+     */
+    allow?: string[];
+    /**
+     * How many days the database's backups are kept: it can be brought back to any moment of them. 1 to 35.
+     */
+    backup_days?: number;
+};
+/**
+ * A change to a database; a field left out stays as it is.
+ */
+export type DatabaseUpdate = {
+    /**
+     * Who may connect, as addresses or CIDRs (203.0.113.7, 203.0.113.0/24), 50 at most; anyone with the password when empty.
+     */
+    allow?: string[];
+    /**
+     * How many days the database's backups are kept: it can be brought back to any moment of them. 1 to 35.
+     */
+    backup_days?: number;
+    /**
+     * The database's size (see `Database.size`); one that is paid for is open to the platform's own project and those named for it alone, as it is opened (403 `size_not_available`). One of the same machine and disk and no larger volume — hobby to free — changes in place. Any other moves through an instance of the new size beside the one that serves, made where the new size lives (a disk of its own, or a SAN volume of its own), which then takes over: the database serves on meanwhile (`state` resizing); its sessions on the direct port end once, when its primary moves, and new logins and transactions wait a few seconds for it. One asleep is woken for its move — its awake hours or disk traffic spent or not, when the size it moves to has no such limit; to one whose it has spent, it sleeps — and the move's time counts against none of them. One down for want of room, moved to a size of a larger volume, is given that room first, in place, and moves once it serves. A move that has not come to its switchover within two hours, and a second for every 10 MB the database holds, is let go: the database stays its size, and `state_reason` says why until its size is changed again — as is one whose primary went down three times before it came to its switchover. One whose primary moves where the move did not ask is stopped, both its instances kept (`state_reason`); onto its instance of the new size, ready — as a node drained moves it — it has come to its switchover. One whose instance of the new size does not take over within five minutes of its switchover says so in `state_reason`, and moves on once it does. Its disk never shrinks. While it moves it serves with the connections of the one of the two sizes that takes fewer; the machines given it are rolled out to their share of the new size's — at once when it takes fewer, once it has moved when it takes more. A size smaller than what it holds is refused (409 `database_too_large`), as is one of a smaller quota while what it holds is not measured yet (409 `database_not_measured`, Retry-After), and so is one the project's limit has no room for (409 `machines_over_limit`), a second free database (409 `free_database_taken`), or one whose connections are too few for the copies the machines given it run (409 `database_connections_short`).
+     */
+    size?: "dedicated-1x" | "dedicated-2x" | "free" | "hobby" | "shared-1g" | "shared-2g" | "shared-4g";
+};
+/**
+ * Whose password is made new.
+ */
+export type PasswordChange = {
+    /**
+     * owner: the database's owner; app: the application's login, the one the machines given the database are started with.
+     */
+    role: "app" | "owner";
+};
+/**
+ * One role's way in, ready to paste, with its password — in its URLs too — when the answer is the one that made it: a login whose password was made earlier carries no password, and [YOUR-PASSWORD] where it would be in its URLs.
+ */
+export type DatabaseLogin = {
+    /**
+     * The role's user name.
+     */
+    user: string;
+    /**
+     * Its password, in the answer that made it alone: the answer that opened the database holds both logins', the one that made a password new holds that one. No answer holds it again.
+     */
+    password?: string;
+    /**
+     * A URL straight to Postgres, TLS checked (sslmode=verify-full).
+     */
+    url: string;
+    /**
+     * A URL through PgBouncer (transaction pooling): a session's SET, LISTEN and advisory locks do not hold there.
+     */
+    pooled_url: string;
+    /**
+     * The user to connect as from a client that sends no TLS server name (libpq before 14, some drivers): the database it means rides on the user.
+     */
+    user_for_clients_without_sni: string;
+    /**
+     * A psql command that connects.
+     */
+    psql: string;
+    /**
+     * A JDBC URL.
+     */
+    jdbc: string;
+    /**
+     * The two lines of a Prisma schema's env: the pooled URL for queries (DATABASE_URL), the direct one for migrations (DIRECT_URL).
+     */
+    prisma_env: string;
+};
+/**
+ * How to connect to a database, with the passwords just made.
+ */
+export type DatabaseCredentials = {
+    /**
+     * Where it answers.
+     */
+    host: string;
+    /**
+     * Its port straight to Postgres.
+     */
+    port: number;
+    /**
+     * Its port through PgBouncer.
+     */
+    pooled_port: number;
+    /**
+     * The Postgres database to connect to.
+     */
+    database: string;
+    owner: DatabaseLogin;
+    app: DatabaseLogin;
+};
+/**
+ * A job the machine's program says it runs on a schedule. The platform calls it when it is due — POST /_palbase/jobs/<name> on the machine's own port, with {"job","run_id","scheduled_at","attempt"}, signed as a webhook is (Palbase-Signature) with the key in the machine's PALBASE_PLATFORM_SECRET — waking the machine for it; of a machine's copies one is called. A program says its jobs at GET /_palbase/jobs (asked once each version comes up); nothing from outside reaches /_palbase/ on a machine. One run of a job at a time: a job due again while its last run is not over is skipped. A 2xx answer is done, 404 is no such job in this version, anything else — or no answer within its timeout — is an attempt that failed, made again after 10 s, 20 s, … five minutes at most.
+ */
+export type Job = {
+    name: string;
+    /**
+     * Five fields, as cron's: minute hour day-of-month month day-of-week, in UTC.
+     */
+    schedule: string;
+    /**
+     * How long an attempt has, in seconds.
+     */
+    timeout: number;
+    /**
+     * How many more attempts a run has after its first fails.
+     */
+    retries: number;
+    /**
+     * When it is next due.
+     */
+    next_at: string;
+    last_run?: JobRun;
+};
+/**
+ * One run of a job: the same run (id, the program's run_id) through every attempt it took.
+ */
+export type JobRun = {
+    id: string;
+    /**
+     * When it was due.
+     */
+    scheduled_at: string;
+    /**
+     * running: an attempt is with the machine; waiting: its last attempt failed and another is due; succeeded; failed: no attempt left; skipped: not run — its last run was not over, or the machine's version has no such job (reason).
+     */
+    state: "running" | "waiting" | "succeeded" | "failed" | "skipped";
+    attempt: number;
+    /**
+     * Why an attempt failed, or why the run was skipped.
+     */
+    reason?: string;
+    started_at: string;
+    finished_at?: string;
+};
+/**
+ * A machine's jobs, as its running version said them, by name.
+ */
+export type JobList = {
+    jobs: Job[];
+};
+/**
+ * A job's latest runs (50 at most), newest first; runs are kept for 7 days.
+ */
+export type JobRunList = {
+    runs: JobRun[];
+};
+/**
+ * One line a machine wrote — a line of the NDJSON answer of GET /machines/{name}/logs.
+ */
+export type MachineLogLine = {
+    /**
+     * When it was written, to the nanosecond.
+     */
+    ts: string;
+    /**
+     * Tells two lines apart, and the same line read twice the same; ids sort as the lines do.
+     */
+    id: string;
+    stream: "stdout" | "stderr";
+    /**
+     * The copy of the machine (or its migration run) that wrote it.
+     */
+    pod: string;
+    /**
+     * The version of the machine the pod ran.
+     */
+    generation: number;
+    /**
+     * The machine itself, or a migration run of it.
+     */
+    source: "machine" | "migration";
+    line: string;
+};
+/**
+ * What a machine used, bucket by bucket, oldest first. A bucket none of whose minutes was measured is no row.
+ */
+export type MachineMetrics = {
+    /**
+     * What a row covers: the one asked for, or the window's own.
+     */
+    bucket: "minute" | "hour" | "day";
+    limits: MachineLimits;
+    rows: MachineUsage[];
+};
+/**
+ * What the machine's size gives each copy now, and how many copies it runs while awake.
+ */
+export type MachineLimits = {
+    /**
+     * A copy's CPU ceiling, in millicores.
+     */
+    cpu_millicores: number;
+    /**
+     * A copy's memory, in bytes.
+     */
+    memory_bytes: number;
+    /**
+     * How many copies it runs while it is awake.
+     */
+    replicas: number;
+};
+/**
+ * One bucket of what a machine used. Every field is a gauge.
+ */
+export type MachineUsage = {
+    /**
+     * When the bucket begins, in Unix milliseconds (UTC).
+     */
+    bucket_ms: number;
+    /**
+     * How many minutes were measured in the bucket.
+     */
+    samples: number;
+    /**
+     * CPU, summed over its copies: the average of the minutes measured.
+     */
+    cpu_avg_millicores: number;
+    /**
+     * CPU, summed over its copies: the most of a minute measured.
+     */
+    cpu_max_millicores: number;
+    /**
+     * Memory (the working set), summed over its copies: the average of the minutes measured.
+     */
+    memory_avg_bytes: number;
+    /**
+     * Memory (the working set), summed over its copies: the most of a minute measured.
+     */
+    memory_max_bytes: number;
+    /**
+     * The most copies that ran in a minute measured.
+     */
+    replicas_max: number;
+    /**
+     * The most CPU one copy used in a minute measured: what limits.cpu_millicores holds it to.
+     */
+    cpu_replica_max_millicores: number;
+    /**
+     * The most memory one copy used in a minute measured: what limits.memory_bytes holds it to.
+     */
+    memory_replica_max_bytes: number;
+};
+/**
+ * A database's usage, bucket by bucket, oldest first. A bucket in which nothing was counted or measured is no row.
+ */
+export type DatabaseMetrics = {
+    /**
+     * What a row covers: the one asked for, or the window's own.
+     */
+    bucket: "hour" | "day";
+    limits: DatabaseLimits;
+    rows: DatabaseUsage[];
+};
+/**
+ * What the database's size holds at most, and the connections it takes.
+ */
+export type DatabaseLimits = {
+    /**
+     * The most it holds (its quota): past it, it is read-only.
+     */
+    size_bytes: number;
+    /**
+     * The connections it takes (Postgres' max_connections).
+     */
+    connections: number;
+};
+/**
+ * One bucket of a database's usage.
+ */
+export type DatabaseUsage = {
+    /**
+     * When the bucket begins, in Unix milliseconds (UTC).
+     */
+    bucket_ms: number;
+    /**
+     * A gauge: what it held as last measured in the bucket. Absent when it was not measured in it (it slept).
+     */
+    size_bytes?: number;
+    /**
+     * A counter: what of its disk traffic — its own, its archive's padding taken off — was counted in the bucket. Absent for a database of a size on a premium disk, whose traffic is not counted.
+     */
+    traffic_bytes?: number;
+    /**
+     * A counter: how much of its awake time was counted in the bucket, in seconds.
+     */
+    awake_seconds: number;
+    /**
+     * A gauge: the most of its clients' connections to Postgres seen in the bucket. Absent when none was seen (it slept).
+     */
+    connections_max?: number;
+};
+/**
+ * The database a machine is given: the machine is started with where it answers (PALBASE_DB_URL), by the application's login, and with how many connections to it a copy may hold (PALBASE_DB_CONNECTIONS) — a share of what the database's size allows, the copies of every machine given it counted twice (a new version comes up beside the one that serves) and a migration run's share apart. Copies those would not serve are refused (409 `database_connections_short`); the other machines given it roll out to their new share. A change gives it whole: `migrations` left out is false.
+ */
+export type MachineDatabase = {
+    /**
+     * The name of one of the project's databases; "" (with no migrations) gives the machine none.
+     */
+    name: string;
+    /**
+     * The machine's releases run their migrations against the database before they serve (a Palbase backend's); they are run as the database's owner. A database's migrations are one machine's: a second machine asking for them is refused (409 `database_migrated_elsewhere`).
+     */
+    migrations?: boolean;
+};
+/**
+ * When to bring the database back to.
+ */
+export type DatabaseRestore = {
+    /**
+     * The moment, as an RFC 3339 time.
+     */
+    to: string;
+};
+/**
+ * One role's way in, ready to paste, without its password: [YOUR-PASSWORD] stands where it would be in its URLs.
+ */
+export type DatabaseRoleConnection = {
+    /**
+     * The role's user name.
+     */
+    user: string;
+    /**
+     * A URL straight to Postgres, TLS checked (sslmode=verify-full), [YOUR-PASSWORD] in its password's place.
+     */
+    url: string;
+    /**
+     * A URL through PgBouncer (transaction pooling): a session's SET, LISTEN and advisory locks do not hold there.
+     */
+    pooled_url: string;
+    /**
+     * The user to connect as from a client that sends no TLS server name (libpq before 14, some drivers): the database it means rides on the user.
+     */
+    user_for_clients_without_sni: string;
+    /**
+     * A psql command that connects.
+     */
+    psql: string;
+    /**
+     * A JDBC URL.
+     */
+    jdbc: string;
+    /**
+     * The two lines of a Prisma schema's env: the pooled URL for queries (DATABASE_URL), the direct one for migrations (DIRECT_URL).
+     */
+    prisma_env: string;
+};
+/**
+ * How to connect to a database, without its passwords — they are shown once, when they are made: [YOUR-PASSWORD] stands in their place.
+ */
+export type DatabaseConnection = {
+    /**
+     * Where it answers.
+     */
+    host: string;
+    /**
+     * Its port straight to Postgres.
+     */
+    port: number;
+    /**
+     * Its port through PgBouncer.
+     */
+    pooled_port: number;
+    /**
+     * The Postgres database to connect to.
+     */
+    database: string;
+    owner: DatabaseRoleConnection;
+    app: DatabaseRoleConnection;
+};
+/**
+ * A database just opened, with its credentials: the one answer that holds both its passwords.
+ */
+export type DatabaseCreated = {
+    /**
+     * The database's name.
+     */
+    name: string;
+    /**
+     * Where it answers: <name>-<ref>.<the databases' domain>.
+     */
+    host: string;
+    /**
+     * Its port straight to Postgres.
+     */
+    port: number;
+    /**
+     * Its port through PgBouncer (transaction pooling): for clients that open a connection for each request.
+     */
+    pooled_port: number;
+    /**
+     * The database's size. free: 0.25 vCPU, 512 MiB, 1 GB, put to sleep when idle (woken by the next connection in about 10 s), awake 400 hours a month at most, archived after a week asleep (its next connection brings it back from its backup); hobby: 0.25 vCPU, 512 MiB, 5 GB, put to sleep when idle, no monthly limit; shared-1g: 1 GiB, up to 1 vCPU, 10 GB; shared-2g: 2 GiB, up to 2 vCPU, 25 GB; shared-4g: 4 GiB, up to 2 vCPU, 50 GB; dedicated-1x: 1 vCPU of its own, 4 GiB, 25 GB; dedicated-2x: 2 vCPU of its own, 8 GiB, 50 GB. The shared and dedicated sizes never sleep and live on a Premium SSD v2 disk of their own; free and hobby on the platform's SAN. A database past its size's storage turns read-only. What a project's machines and databases reserve between them is held to its limit: a size that does not fit is refused (409 `machines_over_limit`).
+     */
+    size: "dedicated-1x" | "dedicated-2x" | "free" | "hobby" | "shared-1g" | "shared-2g" | "shared-4g";
+    /**
+     * Where its data lives, as its size says: san, the platform's SAN; premium, a Premium SSD v2 disk of its own.
+     */
+    disk: "premium" | "san";
+    /**
+     * Who may connect, as addresses or CIDRs (203.0.113.7, 203.0.113.0/24), 50 at most; anyone with the password when empty.
+     */
+    allow: string[];
+    /**
+     * How many days the database's backups are kept: it can be brought back to any moment of them. 1 to 35.
+     */
+    backup_days: number;
+    /**
+     * starting: on its way up; awake: answering; asleep: idle, woken by the next connection; archived: asleep for a week, its next connection brings it back from its backup; restoring: being brought back to a moment of its backups; failed: it cannot start (`state_reason` says why) — a restore could not bring it back, even to the latest moment of its backups; another restore may be asked for.
+     */
+    state: "archived" | "asleep" | "awake" | "failed" | "restoring" | "starting";
+    /**
+     * Why it is in its state, when that needs saying.
+     */
+    state_reason?: string;
+    /**
+     * When it was deleted; it may be taken back until `purge_after`.
+     */
+    deleted_at?: string;
+    /**
+     * When a deleted database, its volume and its backups are gone for good.
+     */
+    purge_after?: string;
+    created_at: string;
+    updated_at: string;
+    /**
+     * How long it has run this month, in hours.
+     */
+    awake_hours?: number;
+    /**
+     * How long its size lets it run in a month, in hours: past it, it sleeps until the month ends, and a client is told so. Absent for a size with no such limit.
+     */
+    awake_hours_limit?: number;
+    /**
+     * How much it held when last measured — every database in it summed, the ones its owner made too — measured while it is awake. Absent before its first measure.
+     */
+    used_bytes?: number;
+    /**
+     * The most its size holds. Past it, it is read-only.
+     */
+    quota_bytes: number;
+    /**
+     * It holds its quota: a transaction takes no writes unless it asks to — BEGIN READ WRITE, to make room with DROP, TRUNCATE, or DELETE and then VACUUM FULL (a DELETE alone frees no room) — and it reads on. Once it holds less than 95% of its quota it takes writes again, within a minute.
+     */
+    read_only: boolean;
+    /**
+     * A change of its passwords (POST …/password) has not reached the database yet: the new password works once this is false, a few seconds after. A client that hands the new password on waits for it.
+     */
+    password_changing: boolean;
+    /**
+     * What it has read from and written to its disk this month: its SAN volume's traffic, counted every minute from its node's device. Absent for a size on a premium disk, whose traffic is not counted.
+     */
+    traffic_bytes?: number;
+    /**
+     * How much its size lets it read from and write to its disk in a month: past it, it sleeps until the month ends, and a client is told so. Absent for a size with no such limit.
+     */
+    traffic_limit_bytes?: number;
+    credentials: DatabaseCredentials;
+};
+/**
+ * A database's tables, by schema then name.
+ */
+export type DatabaseSchema = {
+    tables: DatabaseTable[];
+};
+/**
+ * A table of a database.
+ */
+export type DatabaseTable = {
+    /**
+     * The table's name: bare in public, schema.table in any other schema.
+     */
+    name: string;
+    /**
+     * Row-level security is on for it.
+     */
+    rls: boolean;
+    /**
+     * Its columns, in its order.
+     */
+    columns: DatabaseColumn[];
+};
+/**
+ * A column of a table.
+ */
+export type DatabaseColumn = {
+    name: string;
+    /**
+     * Its type as Postgres writes it (format_type): varchar(40), timestamp with time zone, integer[].
+     */
+    type: string;
+    /**
+     * It takes NULL.
+     */
+    nullable: boolean;
+    /**
+     * It is of the table's primary key.
+     */
+    primary_key: boolean;
+    /**
+     * The column a foreign key of it points at, as table.column (its table named as a table is: schema.table.column outside public). Absent when none does.
+     */
+    references?: string;
+};
+/**
+ * A statement for the console.
+ */
+export type DatabaseQuery = {
+    /**
+     * One statement, 64 KiB at most.
+     */
+    sql: string;
+    /**
+     * How many of its rows to answer, 1 to 1000; a value outside that range is refused.
+     */
+    limit?: number;
+};
+/**
+ * What a statement answered.
+ */
+export type DatabaseQueryResult = {
+    /**
+     * Its columns' names, in order; two may share a name.
+     */
+    columns: string[];
+    /**
+     * Its rows, each an array of its values in the columns' order.
+     */
+    rows: unknown[][];
+    /**
+     * How many rows are in rows.
+     */
+    row_count: number;
+    /**
+     * The statement answered more rows than limit.
+     */
+    truncated: boolean;
+    /**
+     * How long the statement took, in milliseconds.
+     */
+    duration_ms: number;
+};
+/**
+ * A statement Postgres refused: the error envelope, with its SQLSTATE.
+ */
+export type DatabaseQueryError = {
+    /**
+     * Machine-readable error code (snake_case)
+     */
+    error: string;
+    /**
+     * Postgres' message
+     */
+    error_description: string;
+    /**
+     * Correlation ID for log/audit lookup
+     */
+    request_id: string;
+    /**
+     * Seconds to wait before retrying; present on a refusal that ends with time.
+     */
+    retry_after?: number;
+    /**
+     * HTTP status code (mirrors the response status)
+     */
+    status: number;
+    /**
+     * The SQLSTATE Postgres refused it with (25006: a write in the read-only transaction; 42601: a syntax error, or more than one statement; 57014: out of time).
+     */
+    sqlstate: string;
+};
+/**
+ * A statement refused: by Postgres, or as it was asked.
+ */
+export type DatabaseQueryRefusal = ErrorResponse | DatabaseQueryError;
+export type MachineSize = {
+    /**
+     * The size's name, as `size` names it.
+     */
+    name: string;
+    /**
+     * shared: a fraction of a CPU as its ceiling, put to sleep when idle; dedicated: whole CPUs of its own, never asleep.
+     */
+    class: "shared" | "dedicated";
+    /**
+     * Its CPU ceiling, in CPUs.
+     */
+    vcpu: number;
+    /**
+     * Its memory, its own in either class.
+     */
+    memory_mib: number;
+    /**
+     * How much it may write to its own disk.
+     */
+    disk_mib: number;
+    /**
+     * An idle machine of this size is put to sleep, and woken by its next request.
+     */
+    sleeps: boolean;
+    /**
+     * A size open to every project; the others are paid for.
+     */
+    free: boolean;
+    /**
+     * This project may open one of this size now (for a machine: open one, or move one to it).
+     */
+    available: boolean;
+    /**
+     * Why the size is not open to this project; absent when it is.
+     */
+    reason?: string;
+};
+export type MachineSizeList = {
+    /**
+     * Every machine size, smallest first.
+     */
+    sizes: MachineSize[];
+};
+export type MachineNetwork = {
+    /**
+     * Where a machine's connections to the internet leave from: ranges (CIDR, such as 203.0.113.8/29) or addresses. An allowlist names each whole range: a connection may leave from any address in it.
+     */
+    outbound_ips: string[];
+    /**
+     * Every Palbase machine, of every project, leaves from these addresses: an allowlist of them does not tell projects apart.
+     */
+    shared: boolean;
+};
+export type DatabaseSize = {
+    /**
+     * The size's name, as `size` names it.
+     */
+    name: string;
+    /**
+     * Its CPU ceiling, in CPUs.
+     */
+    vcpu: number;
+    /**
+     * Its memory.
+     */
+    memory_mib: number;
+    /**
+     * The most it may hold; past it it turns read-only.
+     */
+    storage_bytes: number;
+    /**
+     * An idle database of this size is put to sleep, and woken by its next connection.
+     */
+    sleeps: boolean;
+    /**
+     * How long it may be awake in a month; absent for no limit. Past it it sleeps until the month ends.
+     */
+    awake_hours_per_month?: number;
+    /**
+     * How much it may read from and write to its disk in a month; absent for no limit.
+     */
+    traffic_bytes_per_month?: number;
+    /**
+     * A week asleep, its volume is taken back and its next connection brings it back from its backup.
+     */
+    archives: boolean;
+    /**
+     * A size counted against the project's free databases; the others are paid for.
+     */
+    free: boolean;
+    /**
+     * This project may open one of this size now (for a machine: open one, or move one to it).
+     */
+    available: boolean;
+    /**
+     * Why the size is not open to this project; absent when it is.
+     */
+    reason?: string;
+};
+export type DatabaseSizeList = {
+    /**
+     * Every database size, the ones that sleep first.
+     */
+    sizes: DatabaseSize[];
+};
+/** Palbase Machines */
+export declare function client(t: Transport): {
+    /**
+     * List machines
+     *
+     * Lists the project's machines, by name.
+     */
+    listMachines(input?: {
+        query?: {
+            limit?: number; /** The next_cursor of the previous page. Opaque; omit it for the first page. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachinePage>>;
+    /**
+     * Open a machine
+     *
+     * Opens a machine, built from a branch of a repository one of the project's installations of Palbase Cloud reaches: the branch's head is built at once, and every push to it after that changes what the machine is built from (its source's context, else its path). With `deploy_after_checks` a push is built once its commit's checks have passed. The answer's state is `building`; the machine answers at its `url` once its first build is up. A project has 5 machines at most; a name is one machine's. Emits `machine.created`. A machine may be given one of the project's databases (`database`): it is started with where the database answers, a database that is not the project's is refused (400 `database_not_found`), and so are its migrations while another machine runs them (409 `database_migrated_elsewhere`).
+     */
+    createMachine(input: {
+        body: MachineCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Machine>>;
+    /**
+     * List machine sizes
+     *
+     * Every machine size, smallest first: what a machine of it is given, whether it sleeps when idle, and whether this project may open or move a machine to it now. A size that is not open says why (`reason`): a size that is paid for is open to a project that may pay. The list is the module's, not the client's: a client offers what this answers.
+     */
+    listMachineSizes(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachineSizeList>>;
+    /**
+     * Get where machines reach the internet from
+     *
+     * The addresses a machine's connections to the internet leave from: what a provider's allowlist names (a bank's, a payment or SMS provider's). They are shared: every Palbase machine, of every project, leaves from them — an allowlist of them says "from Palbase", not "from this project", so a provider still knows a project by its own credentials. They stay the same as the platform changes; a change of them is announced before it is made.
+     */
+    getMachineNetwork(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachineNetwork>>;
+    /**
+     * Connect GitHub
+     *
+     * Answers where the project's owner installs Palbase Cloud on the GitHub account whose repositories machines are built from. Back from GitHub, the user is shown the account and the repositories of it they can push to, and connects them to the project by writing its ref. The link holds 15 minutes.
+     */
+    connectGitHub(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Connect>>;
+    /**
+     * List installations
+     *
+     * The project's installations of Palbase Cloud.
+     */
+    listInstallations(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, InstallationList>>;
+    /**
+     * Connect an installation
+     *
+     * Connects an installation of Palbase Cloud the user reaches, with the user's own GitHub token for the App (a CLI's device flow): the project reaches the repositories of it that user can push to — connected again, what they can push to now. Refused when GitHub says the user cannot reach it, or push to any repository of it. The user taking their authorization of the App back on GitHub disconnects what they connected.
+     */
+    linkInstallation(input: {
+        body: InstallationLink; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Installation>>;
+    /**
+     * Disconnect an installation
+     *
+     * Disconnects one of the project's installations; refused while a machine is built from it.
+     */
+    unlinkInstallation(input: {
+        path: {
+            installation: number;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * List repositories
+     *
+     * Every repository the project's installations reach — of each, those the user who connected it could reach: what a machine may be built from.
+     */
+    listRepositories(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, RepositoryList>>;
+    /**
+     * Read a machine
+     *
+     * Reads one machine: what was asked for, and what runs.
+     */
+    getMachine(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Machine>>;
+    /**
+     * Delete a machine
+     *
+     * Takes the machine away: its address stops answering, and its name is free at once. Emits `machine.deleted`.
+     */
+    deleteMachine(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change a machine
+     *
+     * Changes the machine's source, size, port, env, secrets or whether a push waits for its commit's checks (`deploy_after_checks`) and for which (`deploy_checks`, `deploy_checks_app`). A new size, port, env or secrets rolls out beside the version that serves; a new source is built, and rolls out once its build is up. Emits `machine.updated`. A machine may be given one of the project's databases (`database`): it is started with where the database answers, a database that is not the project's is refused (400 `database_not_found`), and so are its migrations while another machine runs them (409 `database_migrated_elsewhere`).
+     */
+    updateMachine(input: {
+        path: {
+            name: string;
+        };
+        headers?: {
+            "If-Match"?: string;
+        };
+        body: MachineUpdate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Machine>>;
+    /**
+     * List a machine's builds
+     *
+     * A machine's builds, newest first: every commit of its branch built for it, and what became of each.
+     */
+    listBuilds(input: {
+        path: {
+            name: string;
+        };
+        query?: {
+            limit?: number; /** The next_cursor of the previous page. Opaque; omit it for the first page. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, BuildPage>>;
+    /**
+     * Build and roll out the branch's head
+     *
+     * Asks for a build of the head of the machine's branch now (a manual deploy): the build is queued, and rolled out beside the version serving once it succeeds. A head built before is built again — its build failed on something passing, or what it pulls in changed. Asked again before the build starts, it is that one build. The machine's `build_requested` is true until the build is queued; its newest build is then the one asked for. The project's builds a day hold for it as for a push.
+     */
+    deployMachine(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, Machine>>;
+    /**
+     * Read a build
+     *
+     * One build of the machine.
+     */
+    getBuild(input: {
+        path: {
+            name: string; /** The build's id. */
+            build: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Build>>;
+    /**
+     * Read a build's log
+     *
+     * The build's log, its last MiB: where a failure is. There once the build has started (log_not_ready before, while it waits for its checks too); a build that ended before it ran has none (no_log).
+     */
+    getBuildLog(input: {
+        path: {
+            name: string; /** The build's id. */
+            build: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Response>>;
+    /**
+     * Return to a build
+     *
+     * Returns the machine to one of its builds that succeeded: a new version, rolled out beside the one that serves. The only change of what a machine runs not made by a push. Emits `machine.updated`.
+     */
+    rollbackMachine(input: {
+        path: {
+            name: string;
+        };
+        body: Rollback; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Machine>>;
+    /**
+     * List the databases
+     *
+     * Lists the project's databases by name, deleted ones that may still be taken back among them.
+     */
+    listDatabases(input?: {
+        query?: {
+            limit?: number; /** The next_cursor of the previous page. Opaque; omit it for the first page. */
+            cursor?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabasePage>>;
+    /**
+     * Open a database
+     *
+     * Opens a database: its volume is made and it starts; it answers once its state is awake. The answer holds its owner's and its application's passwords, shown this once: no answer holds them again (a new one is made with POST /databases/{name}/password). A project has one database of a free size at a time. A size that is paid for is not open yet — none is charged for — but to the platform's own project and those named for it: another project is refused (403 `size_not_available`). Emits `database.created`.
+     */
+    createDatabase(input: {
+        body: DatabaseCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, DatabaseCreated>>;
+    /**
+     * List database sizes
+     *
+     * Every database size, the ones that sleep first: what a database of it is given and may hold, its monthly limits, and whether this project may open one of it now. A size that is not open says why (`reason`): a size that is paid for is open to a project that may pay, and the free size to a project that has not its free databases already (a deleted one counting until it is purged).
+     */
+    listDatabaseSizes(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseSizeList>>;
+    /**
+     * Read a database
+     *
+     * Reads one database: what was asked for, and what runs.
+     */
+    getDatabase(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Database>>;
+    /**
+     * Delete a database
+     *
+     * Takes the database away: it stops answering at once. Its volume and backups are kept for 7 days, and it may be taken back until then (POST …/undelete), or purged at once (POST …/purge); its name stays taken until it is purged. A database a machine is given is refused (409 `database_in_use`): give the machine another or none first; so is one moving to another size (409 `database_resizing`): it can be deleted once it has moved, or its move is let go. Emits `database.deleted`.
+     */
+    deleteDatabase(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * Change a database
+     *
+     * Changes who may connect to the database, how long its backups are kept, and its size. A change of size is answered at once (202), the database as it moves to it; the others with the database as changed (200). Emits `database.updated`.
+     */
+    updateDatabase(input: {
+        path: {
+            name: string;
+        };
+        body: DatabaseUpdate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Database> | Reply<202, Database>>;
+    /**
+     * Take a database back
+     *
+     * Takes a deleted database back within 7 days of its deletion: it starts again with the data it had. Emits `database.undeleted`.
+     */
+    undeleteDatabase(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Database>>;
+    /**
+     * Purge a deleted database
+     *
+     * Takes a deleted database away for good now, instead of at the end of its 7 days: it no longer counts toward the project's databases at once, and its volume and its backups are removed — it cannot be taken back. Its name is free once it has gone. A database not deleted is refused (409 `database_not_deleted`); one purged already is purged (204). Emits `database.purged`.
+     */
+    purgeDatabase(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<204, undefined>>;
+    /**
+     * How to connect to a database
+     *
+     * Answers how to connect to the database without its passwords — they are shown once, when they are made: ready-made URLs (direct and pooled), a psql command, a JDBC URL and the lines of a Prisma schema's env, for its owner and for the application's login, with [YOUR-PASSWORD] where the password goes.
+     */
+    getDatabaseCredentials(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseConnection>>;
+    /**
+     * Make a password new
+     *
+     * Makes the owner's or the application's password new and answers the credentials with it, shown this once — the other login carries no password, [YOUR-PASSWORD] in its URLs; the new password works once the database has taken it, a few seconds after. The application's is set on its second login, and the machines given the database move to it with none of their connections refused; the old login keeps working until the next change — to shut out a leaked application password, make it new twice. A change waits for the one before it to reach the database (409 `password_change_pending`, with Retry-After), as does the first while the database starts. Emits `database.password_changed`.
+     */
+    changeDatabasePassword(input: {
+        path: {
+            name: string;
+        };
+        body: PasswordChange; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseCredentials>>;
+    /**
+     * List a machine's jobs
+     *
+     * The jobs the machine's running version says it runs on a schedule, each with when it is next due and its latest run.
+     */
+    listJobs(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, JobList>>;
+    /**
+     * List a job's runs
+     *
+     * A job's latest runs, newest first, with the attempts each took and why one failed or was skipped.
+     */
+    listJobRuns(input: {
+        path: {
+            name: string; /** The job's name. */
+            job: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, JobRunList>>;
+    /**
+     * Read what a machine wrote
+     *
+     * What the machine's copies and its migration runs wrote to stdout and stderr, oldest first — or newest first with order=desc — as NDJSON: one MachineLogLine a line; with q, those lines alone that hold its text. Lines are kept for 7 days, from every version of the machine — one that did not come up too. A machine's lines are kept up to 1200 a minute; past it the rest of that minute is not. With follow=true the answer is held open (5 minutes at most, and until the machine is deleted; a project holds 5 followed reads open at once, a sixth is 429 too_many_follows) and what the machine writes next follows as it comes; a caller whose connection ends goes on with since= the time of the last line it had — a line may then come twice, and its id says so. A newest-first read pages back the same way: until= the time of the last line it had, which is inclusive in that order.
+     */
+    readMachineLogs(input: {
+        path: {
+            name: string;
+        };
+        query?: {
+            since?: string; /** Until when: exclusive, and with order=desc inclusive, so that a newest-first read goes on from the time of the last line it had; now when left out. Not with follow. */
+            until?: string; /** How many lines at most (a followed read: before it follows). */
+            lines?: number; /** Hold the answer open and send what the machine writes next. */
+            follow?: boolean; /** asc: oldest first. desc: newest first — the newest lines of the window, up to lines of them. Not with follow. */
+            order?: "asc" | "desc"; /** Only the lines that hold this text, in any case. It is the text itself, no pattern: % and _ are themselves, and so is a backslash. 256 characters at most. A followed read follows those lines alone. */
+            q?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Response>>;
+    /**
+     * Read what a machine used over time
+     *
+     * What the machine used, bucket by bucket, oldest first — what Studio's charts draw. Once a minute the module reads its pods' usage from the cluster's metrics server — CPU averaged over the minute the server read it, memory (the working set) as it was then — and keeps it summed over the machine's copies, at the minute it was read. A minute nobody measured — the machine slept, or a pod had only just started — is in no bucket, and a bucket none of whose minutes was measured is no row: nothing is filled in, carried across a gap or made up when read. Every field of a row is a gauge: `samples` is how many minutes were measured in the bucket; `cpu_avg_millicores` and `memory_avg_bytes` are their average, and `cpu_max_millicores` and `memory_max_bytes` their most, summed over the copies that ran; `replicas_max` is the most copies that ran in a minute (one more than the machine has while a new version comes up beside the one that serves); `cpu_replica_max_millicores` and `memory_replica_max_bytes` are the most one copy used — what `limits` holds a copy to. `limits` is what the machine's size gives a copy now — a shared size wakes with a whole CPU (1000m) and is brought down to its own once it answers — and how many copies it runs while awake. Kept: a machine's minutes 48 hours, its hours 30 days; what is older is deleted, and a deleted machine's is deleted within the hour after it has gone. Buckets are UTC: minute, hour, day.
+     */
+    getMachineMetrics(input: {
+        path: {
+            name: string;
+        };
+        query?: {
+            window_seconds?: number; /** What a row covers. minute reaches 172800 seconds (48 hours) back at most (400 `invalid_bucket` past it). When left out: minute for a window of 6 hours or less, hour up to 7 days, day beyond. */
+            bucket?: "minute" | "hour" | "day";
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachineMetrics>>;
+    /**
+     * Read a machine's API contract
+     *
+     * The contract (OpenAPI) of the build the machine serves from, kept with the build so it is answered without waking the machine and two versions never mix. A palbase/backend app's is written as its build ends: the build's image is run once — the machine neither woken nor changed, the run given none of its secrets — and its app reads its source for what each route answers and throws, and writes the contract; until it has, the answer is 503 `contract_pending` with Retry-After, and a build whose app wrote none is 422 `contract_refused`, saying why (a route its source does not type, a source that does not compile, a palbase/backend older than contracts written at build time). Another app's is read where the machine's openapi_path says, once that build's version alone answered at the machine's address — never while an older one still answered beside it — asked on the platform's own channel, signed with the machine's PALBASE_PLATFORM_SECRET; until it has been read it is asked live: a sleeping machine is woken for it, the call held a few seconds (503 `machine_waking` with Retry-After past that); a machine with no build up yet answers none (503 `machine_building`). A machine whose app is neither has no contract (404 `not_a_palbase_backend`). The answer carries its SHA-256 (ETag, Palbase-Contract-Digest; the machine's contract_digest): If-None-Match with it answers 304. A contract asked live is read up to 2 MiB (502 `contract_too_large` past it) and must be a JSON object (502 `contract_unreadable`); an app that cannot be asked — its connection ends, it answers late or answers another status — is 503 `machine_unreachable`. A project whose machine time is used up wakes nothing (429 `quota_exceeded`).
+     */
+    getMachineContract(input: {
+        path: {
+            name: string;
+        };
+        headers?: {
+            "If-None-Match"?: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, MachineContract> | Reply<304, undefined>>;
+    /**
+     * Bring a database back to a moment
+     *
+     * Brings the database back to a moment of its backups: one since it was opened — or last brought back — within its backup days, and not of the last two minutes (its WAL is archived once a minute). It is down meanwhile, its clients told it is being restored; it starts again with the data it held at that moment, its logins' passwords as they are now. Before it goes down, a commit is written on it and archived, so any moment it was quiet at is reached too — a database asleep is woken for it, unless it has slept since before the moment (then nothing was written since, and it is brought back to the latest moment of its backups); brought back, it is awake. A restore whose recovery fails is made again to the latest moment of its backups — nothing it held is lost — and says so in `state_reason`; one whose archive does not take its last WAL within minutes leaves the database as it was. One restore at a time: another is asked for once the last has ended, or failed (`failed`: not even to its latest moment). Emits `database.restoring`, and `database.restore_failed` when it does not bring the database back to its moment.
+     */
+    restoreDatabase(input: {
+        path: {
+            name: string;
+        };
+        body: DatabaseRestore; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<202, Database>>;
+    /**
+     * Read a database's tables
+     *
+     * Answers the database's tables, as Studio's console shows them: every ordinary and partitioned table outside Postgres' own schemas and the framework's (palgres), by schema then name — a table in public named bare, any other schema.table — with its columns in order: type as Postgres writes it, whether it takes NULL, whether it is of the primary key, and the column a foreign key of it points at. Read as the database's owner, in a transaction that takes no writes. A sleeping database is woken, the call held a few seconds for it (503 `database_waking` with Retry-After past that); one being brought back to a moment, or that cannot start, is refused (409). A database runs a few of the console's calls at once (429 `too_many_queries` past them).
+     */
+    getDatabaseSchema(input: {
+        path: {
+            name: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseSchema>>;
+    /**
+     * Read a database's usage over time
+     *
+     * A database's usage, bucket by bucket, oldest first — what Studio's charts draw — kept by the hour and summed into days. `traffic_bytes` and `awake_seconds` are counters: what of the month's disk traffic (its own, its archive's padding taken off, as the database's `traffic_bytes` is) and of its awake time the meter counted in the bucket. They are counted at each minute's turn, into the hour of the minute that ended (what the meter counted in a month's last minute is in no hour: the month's count begins again before it is counted); a bucket with no row counted none. `size_bytes` and `connections_max` are gauges, absent when nothing was measured in the bucket: what the database held as last measured in it — it is measured while it is awake, never while it sleeps — and the most of its clients' connections to Postgres seen, every 15 seconds while it is awake: of every role but the platform's own, directly or through its pools. `limits` is what its size holds at most (`size_bytes`: past it, it turns read-only) and the connections it takes (Postgres' max_connections). Its history begins at the first minute the module counted it. Kept 90 days; what is older is deleted, and a purged database's within the hour after it was purged. A deleted database is read until it is purged, as it is at GET /databases/{name}. Buckets are UTC: hour, day.
+     */
+    getDatabaseMetrics(input: {
+        path: {
+            name: string;
+        };
+        query?: {
+            window_seconds?: number; /** What a row covers. When left out: hour for a window of 7 days or less, day beyond. */
+            bucket?: "hour" | "day";
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseMetrics>>;
+    /**
+     * Run a statement against a database
+     *
+     * Runs one statement against the database and answers its columns and its first rows, as Studio's console shows them: in a transaction that takes no writes — Postgres refuses one (400 `query_failed`, sqlstate 25006) — always rolled back, as the database's owner, sent as one statement of the extended protocol (two are refused: 42601), within 15 s (57014) and 5 s for a lock (55P03). A statement Postgres refuses is answered 400 `query_failed` with its message and SQLSTATE. Each value as JSON: numbers, booleans and null as such, a timestamp in RFC 3339, numeric as a string, bytea as \x and its hex, json and jsonb as the JSON they hold, an array as an array, anything else its text form. A sleeping database is woken, the call held a few seconds for it (503 `database_waking` with Retry-After past that); one being brought back to a moment, or that cannot start, is refused (409). A database runs a few of the console's calls at once (429 `too_many_queries` past them).
+     */
+    queryDatabase(input: {
+        path: {
+            name: string;
+        };
+        body: DatabaseQuery; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, DatabaseQueryResult>>;
+};
+export type Client = ReturnType<typeof client>;