palbase 0.44.2 → 0.45.1

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

@@ -1512,7 +1512,7 @@ export type TaskTypeList = {
     types: TaskType[];
 };
 /**
- * A template written for a test user — its rows by table, as the machine's program said — or why it was not (error: no_template, not_a_test_user, template_failed, template_timeout, machine_unavailable, then a colon and why). again: answered from what was kept when it was written before; the machine was not asked again.
+ * A template written for a test user — its rows by table, as the machine's program said — or why it was not (error: no_template, not_a_test_user, template_failed, template_timeout, machine_unavailable, then a colon and why: no_template names the build that answered and the templates its program has). again: answered from what was kept when it was written before; the machine was not asked again.
  */
 export type TemplateOutcome = {
     name: string;
@@ -1521,22 +1521,42 @@ export type TemplateOutcome = {
     };
     error?: string;
     again?: boolean;
+    /**
+     * The machine's build whose program answered: wrote the template, or said why not. None on a template kept before builds were.
+     */
+    build?: string;
+    /**
+     * That build's commit.
+     */
+    commit?: string;
+    /**
+     * With again: the commit the machine serves now.
+     */
+    serving_commit?: string;
+    /**
+     * With again, when the commit serving now is not the one that wrote it: a template is written once for a user — its rows are that commit's — and a new test user has the serving code's data.
+     */
+    note?: string;
 };
 /**
- * A test user made with a template: its sign-in, shown this once, and what became of the template. The user is made whatever came of the template.
+ * A test user made with a template: its sign-in, shown this once, and what became of the template. A user is made with its template or not at all: one whose template was not written is answered deleted, with no sign-in.
  */
 export type TemplatedUser = {
     user_id: string;
     email: string;
     /**
-     * Its password, shown this once (a test fixture).
+     * Its password, shown this once (a test fixture); none when the user was deleted again.
      */
-    password: string;
+    password?: string;
     /**
      * With with_tokens: an access token for it (a test fixture).
      */
     access_token?: string;
     template: TemplateOutcome;
+    /**
+     * Its template was not written, and the user was deleted again: it has no sign-in.
+     */
+    deleted?: boolean;
 };
 export type TemplatedUserList = {
     users: TemplatedUser[];
@@ -2200,6 +2220,62 @@ export type PreviewLinkListed = {
     expires_at: string;
     created_at: string;
 };
+/**
+ * What became of one template's undo as its user was deleted: run, or why not — the template has no undo, or the version serving has no such template any more; what it wrote is then left to the user's user.deleted.
+ */
+export type UndoOutcome = {
+    template: string;
+    ran: boolean;
+    /**
+     * Why it did not run, when it did not.
+     */
+    note?: string;
+};
+/**
+ * A test user made with a template, deleted: what became of each template's undo.
+ */
+export type TemplatedUserDeleted = {
+    user_id: string;
+    deleted: boolean;
+    undo: UndoOutcome[];
+};
+/**
+ * A refusal of test users with a template: the error envelope, with the build on its way when it is build_in_progress.
+ */
+export type TestUsersConflict = {
+    /**
+     * 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;
+    build?: BuildOnItsWay;
+};
+/**
+ * With build_in_progress: the machine's newest build on its way.
+ */
+export type BuildOnItsWay = {
+    id?: string;
+    commit?: string;
+    /**
+     * requested (a build of the head is asked for; no build yet), waiting_checks, queued, building, testing, waiting_config, rolling out (built; the version before serves), or waking (built, the machine asleep: woken on the version it served, it rolls the new one out — the call woke it)
+     */
+    state: string;
+};
 /** Palbase Machines */
 export declare function client(t: Transport): {
     /**
@@ -2826,7 +2902,7 @@ export declare function client(t: Transport): {
     /**
      * Make test users with a template's data
      *
-     * Makes 1 to 10 test users (auth's: their tokens say test: true) and has the machine's own program write a template's data for each — the backend's seed for one account (palbase/backend's @TestUserTemplate), for a person or an agent to sign in and see a screen with its data. The platform calls the program for each user — POST /_palbase/test-user-templates/<template> on the machine's own port, with {"user": {"id", "email"}, "template"}, signed as a cron's call is, waking the machine for it; the program writes the template in one transaction and answers {"rows": {table: count}}, or refuses a user auth does not say is a test user (403). A user is made whatever came of its template: its template answers its error by name. The same user and template asked again (POST …/test-users/{user}/templates/{template}) answers what was kept, the machine not asked again. The users' passwords (and with with_tokens their access tokens) are test fixtures, shown this once, as auth's test users' are. 409 when auth makes no more test users for the project; 429 quota_exceeded, and no user made, when the project's machines are not run now (its machine time for the period used up, or the project deleted).
+     * Makes 1 to 10 test users (auth's: their tokens say test: true) and has the machine's own program write a template's data for each — the backend's seed for one account (palbase/backend's @TestUserTemplate), for a person or an agent to sign in and see a screen with its data. The platform calls the program for each user — POST /_palbase/test-user-templates/<template> on the machine's own port, with {"user": {"id", "email"}, "template"}, signed as a cron's call is, waking the machine for it; the program writes the template in one transaction and answers {"rows": {table: count}}, or refuses a user auth does not say is a test user (403). A user is made with its template or not at all: one whose template was not written is deleted again (deleted: true, no sign-in), its template answering its error by name — one the program may have written for all the same (it did not answer in time, its connection ended once made, or it answered what a template does not) has the template's undo asked first. One whose undo did not run, or that auth would not delete, is kept for now, its error saying so: the platform asks the undo again and deletes it within the hour. The work for the users made goes on to its end when the request is gone. Each template says the build whose program answered (build, commit). None is made while the machine's newest build is on its way — a build of its head asked for, queued, building, testing, or rolling out while the version before serves: 409 build_in_progress, naming the build, its commit and where it is; ask again once it serves. The same user and template asked again (POST …/test-users/{user}/templates/{template}) answers what was kept, the machine not asked again. The users' passwords (and with with_tokens their access tokens) are test fixtures, shown this once, as auth's test users' are. 409 test_users_refused when auth makes no more test users for the project; 429 quota_exceeded, and no user made, when the project's machines are not run now (its machine time for the period used up, or the project deleted).
      */
     makeTemplatedTestUsers(input: {
         path: {
@@ -2838,7 +2914,7 @@ export declare function client(t: Transport): {
     /**
      * Write a template for a test user
      *
-     * Has the machine's program write a template for a test user this machine made with one (POST /machines/{name}/test-users) — answered from what was kept when it wrote that template for that user before, the machine not asked again (again: true). 429 quota_exceeded when the project's machines are not run now and the template was not written before. 404 when the user is no test user this machine made with a template: a test user is the machine's that made it, another machine of the project neither writes for it nor deletes it.
+     * Has the machine's program write a template for a test user this machine made with one (POST /machines/{name}/test-users) — answered from what was kept when it wrote that template for that user before, the machine not asked again (again: true). That answer says the commit whose program wrote it (commit), the commit the machine serves now (serving_commit), and when they differ what that means (note): a template is written once for a user, a new test user has the serving code's data. 409 build_in_progress, nothing written, while the machine's newest build is on its way and the template was not written before. 429 quota_exceeded when the project's machines are not run now and the template was not written before. 404 when the user is no test user this machine made with a template: a test user is the machine's that made it, another machine of the project neither writes for it nor deletes it.
      */
     templateTestUser(input: {
         path: {
@@ -2851,15 +2927,18 @@ export declare function client(t: Transport): {
     /**
      * Delete a test user made with a template
      *
-     * Has the machine's program undo each template the user was written with — POST /_palbase/test-user-templates/<template>/undo, signed as the template's call; a program with no undo (404) leaves it to its user.deleted — then deletes the user. 502 undo_failed when the program did not undo one: the user is kept, for the delete to be asked again. 429 quota_exceeded, the user kept, when the project's machines are not run now. 404 when the user is no test user this machine made with a template: a test user is the machine's that made it, another machine of the project neither writes for it nor deletes it.
+     * Has the machine's program undo each template the user was written with — POST /_palbase/test-user-templates/<template>/undo, signed as the template's call; a program with no undo for it, or whose serving version has no such template any more (404), leaves it to its user.deleted — then deletes the user — answering, to a request with Prefer: return=representation, what became of each undo: run (ran: true), or why not (note); 204 otherwise. 502 undo_failed when the program did not undo one: the user is kept, for the delete to be asked again. 429 quota_exceeded, the user kept, when the project's machines are not run now. 404 when the user is no test user this machine made with a template: a test user is the machine's that made it, another machine of the project neither writes for it nor deletes it.
      */
     deleteTemplatedTestUser(input: {
         path: {
             name: string; /** The test user's id, as the users made with a template were answered. */
             user: string;
+        };
+        headers?: {
+            Prefer?: 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>>;
+    }): Promise<Reply<200, TemplatedUserDeleted> | Reply<204, undefined>>;
     /**
      * List sites
      *