@archildata/api-types 0.0.52 → 0.0.54

package/index.d.ts

@@ -236,6 +236,57 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/disks/{id}/branches": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List disk branches
+         * @description List every branch of the disk, including branches created from other
+         *     branches, in no particular order.
+         */
+        get: operations["listBranches"];
+        put?: never;
+        /**
+         * Create a writable branch from a checkpoint
+         * @description Create a branch: an independent, writable fork of the disk that starts
+         *     from a committed checkpoint. The checkpoint is looked up on the root
+         *     disk, or on `from_branch` when supplied. Writes on the branch don't
+         *     affect its source.
+         *
+         *     Branch names are unique across the disk, including branches created
+         *     from other branches. Creating a branch with a name that already exists
+         *     returns 409, unless the request carries the `Idempotency-Key` that
+         *     created it, in which case the existing branch is returned with 201. To
+         *     retry safely, send the same `Idempotency-Key` and request body.
+         */
+        post: operations["createBranch"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/disks/{id}/branches/{name}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get a disk branch */
+        get: operations["getBranch"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/disks/{id}/users": {
         parameters: {
             query?: never;
@@ -909,6 +960,41 @@ export interface paths {
 export type webhooks = Record<string, never>;
 export interface components {
     schemas: {
+        /** @description 1-100 letters, digits, hyphens, or underscores. Unique across the disk. */
+        BranchName: string;
+        CreateBranchRequest: {
+            branch_name: components["schemas"]["BranchName"];
+            /** @description Name of a committed checkpoint on the source, which is the root disk or `from_branch` when set. */
+            from_checkpoint_name: string;
+            /** @description Name of the branch the checkpoint was taken on. Omit or leave empty to use the root disk. */
+            from_branch?: string;
+        };
+        BranchResponse: {
+            /** @description ID of the disk the branch belongs to. */
+            root_filesystem_id: string;
+            branch_name: components["schemas"]["BranchName"];
+            /** @description ID of the branch's own writable filesystem. */
+            filesystem_id: string;
+            /** @description Name of the checkpoint the branch started from. */
+            from_checkpoint_name: string;
+            /** @description ID of the filesystem the checkpoint was taken on; the disk ID for the root disk, or the source branch's `filesystem_id`. */
+            from_checkpoint_filesystem_id: string;
+            /**
+             * Format: date-time
+             * @description When the branch was created.
+             */
+            created_at: string;
+        };
+        BranchApiResponse: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["BranchResponse"];
+        };
+        BranchListApiResponse: {
+            /** @example true */
+            success: boolean;
+            data: components["schemas"]["BranchResponse"][];
+        };
         ErrorResponse: {
             /** @example false */
             success: boolean;
@@ -1206,7 +1292,7 @@ export interface components {
         SandboxState: "pending" | "running" | "pausing" | "paused" | "stopping" | "stopped" | "exited" | "failed" | "deleting" | "deleted";
         /** @enum {string} */
         SandboxNetworkAction: "allow" | "deny";
-        /** @description Deny targets take precedence when an address or domain matches both lists. When domain rules or drain selectors are present, TCP port 80 is restricted to HTTP/1.1 or HTTP/2 and plaintext HTTP authority is enforced, but requests matching a transformation rule are rejected unless the rule also forwards. Port 443 is relayed without TLS termination. With domain rules, it is evaluated by TLS SNI and connects to an address the runtime resolves for that name, never the address the guest dialed; names need a matching domain rule or default allow, and connections without a hostname SNI are denied. Only rules with header transformations or forwarding, and drain selectors, terminate TLS, which requires clients to trust the sandbox egress CA; for those, both TLS SNI and HTTP authority are evaluated, and the HTTP authority selects the upstream, any request transformations, and any request forwarding. DNS to the sandbox's configured resolvers is allowed and UDP port 443 is denied. */
+        /** @description Deny targets take precedence when an address or domain matches both lists. When domain rules or drain selectors are present, TCP port 80 is restricted to HTTP/1.1 or HTTP/2 and plaintext HTTP authority is enforced, but requests matching a transformation rule are rejected unless the rule also forwards. Port 443 is relayed without TLS termination. With domain rules, it is evaluated by TLS SNI and connects to an address the runtime resolves for that name, never the address the guest dialed; names need a matching domain rule or default allow, and connections without a hostname SNI are denied. Only rules with header transformations or forwarding, and drain selectors, terminate TLS, which requires clients to trust the sandbox egress CA unless the region serves its sandbox port domain's certificate to egress and the name is exactly one label below that domain; for those, both TLS SNI and HTTP authority are evaluated, and the HTTP authority selects the upstream, any request transformations, and any request forwarding. DNS to the sandbox's configured resolvers is allowed and UDP port 443 is denied. */
         SandboxEgressPolicy: {
             default: components["schemas"]["SandboxNetworkAction"];
             /** @description Allowed IPv4 addresses, CIDR ranges, exact domains, wildcard domains beginning with `*.`, or target objects with optional outbound HTTPS request transformations. A wildcard matches subdomains but not the apex domain, including when applying transformations. */
@@ -1222,7 +1308,7 @@ export interface components {
             transform?: components["schemas"]["SandboxEgressTransform"];
             /**
              * Format: uri
-             * @description Absolute public HTTPS URL that receives this rule's permitted HTTP and HTTPS requests instead of their original upstream. The original path is appended to this URL, and Archil overwrites the archil-forwarded-host, archil-forwarded-scheme, archil-forwarded-port, archil-forwarded-path, and archil-sandbox-id headers with request metadata. A transform on the same rule is applied before forwarding, so the forwarded request carries the transformed headers. URLs containing credentials, a query, or a fragment are rejected.
+             * @description Absolute public HTTPS URL that receives this rule's permitted HTTP and HTTPS requests instead of their original upstream. The original path is appended to this URL, and Archil overwrites the archil-forwarded-host, archil-forwarded-scheme, archil-forwarded-port, archil-forwarded-path, and archil-sandbox-id headers with request metadata. A transform on the same rule is applied before forwarding, so the forwarded request carries the transformed headers. URLs containing credentials, a query, or a fragment are rejected. In regions that serve their sandbox port domain's certificate to egress, a target exactly one label below that domain is presented with that publicly trusted certificate, so clients that do not trust the Archil egress CA can use it as a provider base URL.
              */
             forward_url?: string;
         };
@@ -2960,6 +3046,189 @@ export interface operations {
             500: components["responses"]["InternalError"];
         };
     };
+    listBranches: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description All branches of the disk */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BranchListApiResponse"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            /** @description Missing or invalid authentication credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Disk not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+            /** @description Request timed out */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    createBranch: {
+        parameters: {
+            query?: never;
+            header?: {
+                /** @description A single UUID identifying a create operation. Keys are compared as exact, case-sensitive strings, so retries must send the identical value. */
+                "Idempotency-Key"?: string;
+            };
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["CreateBranchRequest"];
+            };
+        };
+        responses: {
+            /** @description Branch created, or the existing branch returned for a retry with the same Idempotency-Key */
+            201: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BranchApiResponse"];
+                };
+            };
+            /** @description Invalid disk ID, request body, branch name, or Idempotency-Key, or more than one Idempotency-Key header */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                    "text/plain": string;
+                };
+            };
+            /** @description Missing or invalid authentication credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Disk, source branch, or checkpoint not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            /** @description A branch with this name already exists and the request did not carry its Idempotency-Key, or the checkpoint is not yet committed */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+            /** @description Request timed out and the branch may have been created; retry with the same Idempotency-Key and request body */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
+    getBranch: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Disk ID (format `dsk-{16 hex chars}`) */
+                id: components["parameters"]["DiskId"];
+                /** @description Branch name */
+                name: components["schemas"]["BranchName"];
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Branch details */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["BranchApiResponse"];
+                };
+            };
+            400: components["responses"]["ValidationError"];
+            /** @description Missing or invalid authentication credentials */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "text/plain": string;
+                };
+            };
+            /** @description Disk or branch not found */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+            500: components["responses"]["InternalError"];
+            /** @description Request timed out */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ErrorResponse"];
+                };
+            };
+        };
+    };
     addDiskUser: {
         parameters: {
             query?: never;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archildata/api-types",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "API types for the Archil control plane",
   "type": "module",
   "types": "index.d.ts",