palbase 0.23.2 → 0.25.0

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

@@ -209,6 +209,26 @@ export type Machine = {
      * 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;
+    /**
+     * Kept awake: a machine of a size that sleeps is never put to sleep when idle, and is started again at once when it is asleep — while its environment has paid rights (Pay as you go with a balance), which pays its every hour. Without them it sleeps as any; a dedicated size never sleeps.
+     */
+    always_on: boolean;
+    /**
+     * Whether a pull request opened against its branch is previewed: its head built into a machine of its own, <name>-pr<n>, in this environment, with this environment's settings and secrets, answering at <name>-pr<n>-<ref> until the pull request closes; the pull request is told where in a comment. Turn it on in an environment kept for previews, not production's: the pull request's code runs with the environment's secrets.
+     */
+    previews: boolean;
+    /**
+     * Whether a pull request from a fork — another repository, which anyone may open — is previewed too. Off by default: its code would run with the environment's secrets.
+     */
+    preview_forks: boolean;
+    /**
+     * For a pull request's preview: the name of the machine it previews. It is deleted as its pull request closes, and with that machine.
+     */
+    preview_of?: string;
+    /**
+     * For a pull request's preview: the pull request's number.
+     */
+    pull_request?: 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.
@@ -282,6 +302,18 @@ export type MachineCreate = {
      * 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;
+    /**
+     * Keeps it awake (Machine.always_on): open to an environment on Pay as you go with a balance, refused `always_on_not_available` otherwise.
+     */
+    always_on?: boolean;
+    /**
+     * Whether a pull request opened against its branch is previewed: its head built into a machine of its own, <name>-pr<n>, in this environment, with this environment's settings and secrets, answering at <name>-pr<n>-<ref> until the pull request closes; the pull request is told where in a comment. Turn it on in an environment kept for previews, not production's: the pull request's code runs with the environment's secrets. A machine read with Palbase's GitHub App alone (source.access app).
+     */
+    previews?: boolean;
+    /**
+     * Whether a pull request from a fork — another repository, which anyone may open — is previewed too. Off by default: its code would run with the environment's secrets.
+     */
+    preview_forks?: boolean;
     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.
@@ -363,6 +395,18 @@ export type MachineUpdate = {
      * 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;
+    /**
+     * Whether it is kept awake from now on (Machine.always_on): no version changes. Turning it on is open to an environment on Pay as you go with a balance, refused `always_on_not_available` otherwise.
+     */
+    always_on?: boolean;
+    /**
+     * Whether its pull requests are previewed from now on (Machine.previews): the previews open stay until their pull requests close. A preview takes none.
+     */
+    previews?: boolean;
+    /**
+     * Whether a fork's pull requests are previewed from now on (Machine.preview_forks).
+     */
+    preview_forks?: boolean;
     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.
@@ -1405,6 +1449,339 @@ export type MachineDeploy = {
      */
     git_access_token?: string;
 };
+/**
+ * A project's static web site.
+ */
+export type Site = {
+    /**
+     * The site's name in the project.
+     */
+    name: string;
+    /**
+     * Where it answers: <name>-<ref> on the hosting domain, the ref alone for the site named web.
+     */
+    url: string;
+    /**
+     * Every address it answers at, url first.
+     */
+    urls: string[];
+    /**
+     * A path no file answers is answered with /index.html (a single-page app's routes), not 404.
+     */
+    spa: boolean;
+    release: SiteReleaseRef;
+    taken_down: SiteTakenDown;
+    created_at: string;
+    updated_at: string;
+    source: SiteSourceView;
+    build: SiteBuildSettings;
+    /**
+     * Whether a pull request opened against its source's branch is previewed: its head built, with this environment's build settings, into a release of its own that answers at <name>-pr<n>-<ref> until the pull request closes — never what the site serves, none of its releases; the pull request is told where in a comment. Turn it on in an environment kept for previews, not production's.
+     */
+    previews: boolean;
+    /**
+     * Whether a pull request from a fork — another repository, which anyone may open — is previewed too. Off by default: its build would run with the environment's build settings.
+     */
+    preview_forks: boolean;
+};
+/**
+ * The release a site serves; none before its first.
+ */
+export type SiteReleaseRef = ({
+    id: string;
+    /**
+     * The site's releases counted: #1, #2, …
+     */
+    number: number;
+}) | null;
+/**
+ * The platform's operator took the site down (abuse): nothing of it is served until it is restored. None, it was not.
+ */
+export type SiteTakenDown = ({
+    at: string;
+    reason: string;
+}) | null;
+/**
+ * The project's sites, by name.
+ */
+export type SiteList = {
+    sites: Site[];
+};
+/**
+ * A site to open.
+ */
+export type SiteCreate = {
+    /**
+     * The site's name; `web` when left out, which answers at the project's ref.
+     */
+    name?: string;
+    /**
+     * A single-page app: a path no file answers is answered with /index.html.
+     */
+    spa?: boolean;
+    source?: SiteSource;
+    build?: SiteBuildSettings;
+    /**
+     * Whether a pull request opened against its source's branch is previewed: its head built, with this environment's build settings, into a release of its own that answers at <name>-pr<n>-<ref> until the pull request closes — never what the site serves, none of its releases; the pull request is told where in a comment. Turn it on in an environment kept for previews, not production's.
+     */
+    previews?: boolean;
+    /**
+     * Whether a fork's pull requests are previewed (Site.preview_forks).
+     */
+    preview_forks?: boolean;
+};
+/**
+ * What to change of a site; a field left out is unchanged.
+ */
+export type SiteUpdate = {
+    spa?: boolean;
+    source?: SiteSource;
+    build?: SiteBuildSettings;
+    /**
+     * Whether its pull requests are previewed from now on (Site.previews): the previews open stay until their pull requests close.
+     */
+    previews?: boolean;
+    /**
+     * Whether a fork's pull requests are previewed (Site.preview_forks).
+     */
+    preview_forks?: boolean;
+};
+/**
+ * One upload of a site's files.
+ */
+export type SiteRelease = {
+    id: string;
+    number: number;
+    /**
+     * uploading: its files are being sent; ready: kept, and the site may serve it. One never finished is let go of after a day.
+     */
+    state: "uploading" | "ready";
+    /**
+     * Sent from the CLI (upload), or built from a commit (build).
+     */
+    origin: "upload" | "build";
+    /**
+     * The commit it was built from; none for an upload.
+     */
+    commit: string | null;
+    files: number;
+    /**
+     * What its files weigh together, once it is finished.
+     */
+    bytes: number;
+    /**
+     * The site serves it.
+     */
+    serving: boolean;
+    /**
+     * While it uploads (as it is started): the SHA-256 of each file it lists that the project does not keep yet.
+     */
+    missing?: string[];
+    created_at: string;
+    ready_at: string | null;
+};
+/**
+ * A site's releases, newest first.
+ */
+export type SiteReleaseList = {
+    releases: SiteRelease[];
+};
+/**
+ * The files of a release.
+ */
+export type SiteReleaseCreate = {
+    /**
+     * Path → the SHA-256 (hex) of its file. A path starts with /, names a file (no trailing /), holds no . or .. part, no // and no ?, # or \\.
+     */
+    files: {
+        [key: string]: string;
+    };
+};
+/**
+ * The release to serve; none is the one before the release the site serves.
+ */
+export type SiteRollback = {
+    release?: string;
+};
+/**
+ * A file's bytes, as they are.
+ */
+export type SiteFileBytes = Blob;
+/**
+ * A release finished with files missing: the error envelope, and what to send.
+ */
+export type SiteFilesMissing = {
+    error: string;
+    error_description: string;
+    status: number;
+    request_id: string;
+    retry_after?: number;
+    missing: string[];
+};
+/**
+ * Where the site is built from: a push to its branch builds it, and the release its build wrote is served. None for a site deployed from a folder alone.
+ */
+export type SiteSourceView = ({
+    repository: string;
+    branch: string;
+    /**
+     * The site's directory in the repository; "" for its root.
+     */
+    path: string;
+}) | null;
+/**
+ * A GitHub repository's branch and the site's directory in it: one of the environment's installations reaches the repository (machines/github). In a change, a repository of "" takes the site's source away.
+ */
+export type SiteSource = {
+    /**
+     * owner/name
+     */
+    repository: string;
+    branch?: string;
+    /**
+     * The site's directory; none for the repository's root.
+     */
+    path?: string;
+};
+/**
+ * What a site's build runs; each left empty is found in its source: its lockfile (pnpm, yarn, npm, bun), its package.json's build script, the folder its builder writes (dist, build, out, …). A folder with no package.json is served as it is.
+ */
+export type SiteBuildSettings = {
+    install_command?: string;
+    command?: string;
+    /**
+     * The folder the build writes, from the site's directory.
+     */
+    output_dir?: string;
+    /**
+     * What the build runs with — what its pages are sent (VITE_*, NEXT_PUBLIC_*), never a secret: 100 at most.
+     */
+    env?: {
+        [key: string]: string;
+    };
+};
+/**
+ * One build of a site: one commit of its branch.
+ */
+export type SiteBuild = {
+    id: string;
+    commit: string;
+    /**
+     * The commit's message, its first line.
+     */
+    message: string;
+    state: "queued" | "building" | "succeeded" | "failed";
+    /**
+     * Why it failed.
+     */
+    reason?: string;
+    /**
+     * The release it wrote, once it succeeded.
+     */
+    release: string | null;
+    /**
+     * Its run's log (read alone: GET …/builds/{build}).
+     */
+    log?: string;
+    created_at: string;
+    started_at: string | null;
+    finished_at: string | null;
+};
+/**
+ * A site's twenty newest builds, newest first.
+ */
+export type SiteBuildList = {
+    builds: SiteBuild[];
+};
+/**
+ * A pull request's preview of a site or a machine.
+ */
+export type Preview = {
+    /**
+     * The pull request's number.
+     */
+    pull_request: number;
+    /**
+     * The pull request's head it is built at: the newest heard.
+     */
+    commit: string;
+    /**
+     * The pull request is from another repository.
+     */
+    fork: boolean;
+    /**
+     * Where it answers once built.
+     */
+    url: string;
+    /**
+     * building, ready, failed — or closed: its pull request closed, and its address answers no more.
+     */
+    state: "building" | "ready" | "failed" | "closed";
+    /**
+     * A machine's preview: its own machine, by name.
+     */
+    machine?: string;
+    created_at: string;
+    updated_at: string;
+    closed_at?: string;
+};
+/**
+ * A site's or a machine's previews, the fifty newest first.
+ */
+export type PreviewList = {
+    previews: Preview[];
+};
+/**
+ * One record of a domain's DNS.
+ */
+export type DNSRecord = {
+    type: "CNAME" | "TXT";
+    name: string;
+    value: string;
+};
+/**
+ * A domain of the customer's own a site or a machine answers at too. Its owner adds its records to its DNS: the CNAME points it at the platform (at the apex, where DNS takes no CNAME: an ALIAS, ANAME or flattened CNAME to the same target), the TXT shows it is this environment's. It answers once Cloudflare has its certificate and the TXT record is there. A domain is one environment's, platform-wide, until it is deleted there.
+ */
+export type Domain = {
+    /**
+     * The domain: www.example.com, or example.com.
+     */
+    host: string;
+    /**
+     * pending until it answers, then active.
+     */
+    state: "pending" | "active";
+    /**
+     * A domain of its own, not a subdomain: most DNS hosts take no CNAME there.
+     */
+    apex: boolean;
+    /**
+     * What its owner adds to its DNS.
+     */
+    records: DNSRecord[];
+    /**
+     * What stands in its way, as last checked.
+     */
+    problems: string[];
+    checked_at?: string;
+    active_at?: string;
+    created_at: string;
+};
+/**
+ * A site's or a machine's domains, by host.
+ */
+export type DomainList = {
+    domains: Domain[];
+};
+/**
+ * A domain to add.
+ */
+export type DomainCreate = {
+    /**
+     * The domain: www.example.com, or example.com — none of the platform's own.
+     */
+    host: string;
+};
 /** Palbase Machines */
 export declare function client(t: Transport): {
     /**
@@ -1561,6 +1938,52 @@ export declare function client(t: Transport): {
         body?: MachineDeploy; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
         signal?: AbortSignal;
     }): Promise<Reply<202, Machine>>;
+    /**
+     * List a machine's previews
+     *
+     * Lists the previews of a machine's pull requests, the newest first: each one's pull request, head, address, and state — its preview machine's.
+     */
+    listMachinePreviews(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, PreviewList>>;
+    /**
+     * List a machine's domains
+     *
+     * Lists the machine's own domains, by host: each one's state, the records its owner adds to its DNS, and what stands in its way.
+     */
+    listMachineDomains(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, DomainList>>;
+    /**
+     * Add a domain to a machine
+     *
+     * Adds a domain of the customer's own the machine answers at too, once its owner has added the records the answer names to its DNS. Refused when another environment has it (domain_taken), when it is one of the platform's, or past the environment's twenty.
+     */
+    addMachineDomain(input: {
+        path: {
+            name: string;
+        };
+        body: DomainCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Domain>>;
+    /**
+     * Delete a machine's domain
+     *
+     * Takes a domain away: it answers no more at once, and another environment may add it.
+     */
+    deleteMachineDomain(input: {
+        path: {
+            name: string; /** The domain. */
+            host: 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>>;
     /**
      * Read a build
      *
@@ -1975,5 +2398,198 @@ export declare function client(t: Transport): {
         }; /** 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 sites
+     *
+     * Lists the project's sites, by name: a project has 10 at most.
+     */
+    listSites(input?: {
+        signal?: AbortSignal;
+    }): Promise<Reply<200, SiteList>>;
+    /**
+     * Open a site
+     *
+     * Opens a static web site (hosting). It answers at its label on the hosting domain — the project's ref for the site named `web` (the default), `<name>-<ref>` for any other. It serves nothing before its first release: a folder deployed (releases), or a build of its source, which a push to its branch makes.
+     */
+    createSite(input: {
+        body: SiteCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Site>>;
+    /**
+     * Get a site
+     *
+     * Reads a site: where it answers, the release it serves, whether the platform took it down.
+     */
+    getSite(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, Site>>;
+    /**
+     * Delete a site
+     *
+     * Deletes a site: its address serves nothing from now on, and its name is free in the project at once; its releases and files are let go of shortly after.
+     */
+    deleteSite(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 site
+     *
+     * Changes what a site was asked to be: whether a path no file answers is its /index.html (a single-page app), where it is built from (its branch's head is built at once; a repository of "" takes the source away) and what its build runs.
+     */
+    updateSite(input: {
+        path: {
+            name: string;
+        };
+        body: SiteUpdate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Site>>;
+    /**
+     * List a site's releases
+     *
+     * Lists a site's releases, newest first: the ten newest finished ones are kept to return to, with the one it serves and any still uploading.
+     */
+    listSiteReleases(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, SiteReleaseList>>;
+    /**
+     * Start a release
+     *
+     * Starts a release of a site: it lists every path the site will answer and the SHA-256 of the file each one is (20,000 files at most, 25 MiB each, 1 GiB together). The answer names, in `missing`, the files the project does not keep yet: each is sent (`PUT …/files/{digest}`), then the release is finished. A file the project keeps from any release is not sent again.
+     */
+    createSiteRelease(input: {
+        path: {
+            name: string;
+        };
+        body: SiteReleaseCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, SiteRelease>>;
+    /**
+     * Send a release's file
+     *
+     * Sends one file a release lists, as it is: its bytes must be the SHA-256 the path names, or nothing is kept. A file the project keeps already is not read again.
+     */
+    uploadSiteFile(input: {
+        path: {
+            name: string; /** The release's id. */
+            release: string; /** The file's SHA-256: 64 lowercase hex digits. */
+            digest: string;
+        };
+        body: BodyInit;
+        contentType?: 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>>;
+    /**
+     * Finish a release
+     *
+     * Finishes a release whose files are all kept — refused, naming them, while one is missing — and the site serves it at once. Finishing one finished before has the site serve it again.
+     */
+    finishSiteRelease(input: {
+        path: {
+            name: string; /** The release's id. */
+            release: string;
+        }; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, SiteRelease>>;
+    /**
+     * Return to a release
+     *
+     * Has the site serve one of the releases it keeps: the one named, or the one before the release it serves. Served at once.
+     */
+    rollbackSite(input: {
+        path: {
+            name: string;
+        };
+        body: SiteRollback; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<200, Site>>;
+    /**
+     * List a site's builds
+     *
+     * Lists a site's twenty newest builds, newest first.
+     */
+    listSiteBuilds(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, SiteBuildList>>;
+    /**
+     * Build a site now
+     *
+     * Asks for a build of the head of the site's branch now — what a push does: the release it writes is served once it succeeded.
+     */
+    deploySite(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, Site>>;
+    /**
+     * List a site's previews
+     *
+     * Lists the previews of a site's pull requests, the newest first: each one's pull request, head, address, and state — its newest build's of that head.
+     */
+    listSitePreviews(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, PreviewList>>;
+    /**
+     * List a site's domains
+     *
+     * Lists the site's own domains, by host: each one's state, the records its owner adds to its DNS, and what stands in its way.
+     */
+    listSiteDomains(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, DomainList>>;
+    /**
+     * Add a domain to a site
+     *
+     * Adds a domain of the customer's own the site answers at too, once its owner has added the records the answer names to its DNS. Refused when another environment has it (domain_taken), when it is one of the platform's, or past the environment's twenty.
+     */
+    addSiteDomain(input: {
+        path: {
+            name: string;
+        };
+        body: DomainCreate; /** Stops the call: the request in flight, a wait before a retry, a proof-of-work being solved. */
+        signal?: AbortSignal;
+    }): Promise<Reply<201, Domain>>;
+    /**
+     * Delete a site's domain
+     *
+     * Takes a domain away: it answers no more at once, and another environment may add it.
+     */
+    deleteSiteDomain(input: {
+        path: {
+            name: string; /** The domain. */
+            host: 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>>;
+    /**
+     * Get a site's build
+     *
+     * Reads one build of a site, with its log.
+     */
+    getSiteBuild(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, SiteBuild>>;
 };
 export type Client = ReturnType<typeof client>;