hanzoai 8.5.621 → 8.5.640

package/dist/esm/api/auto-api.d.ts

@@ -16,6 +16,7 @@ import type { AutoAutomation } from '../models';
 import type { AutoAutomationIn } from '../models';
 import type { AutoAutomationPage } from '../models';
 import type { AutoAutomationPatch } from '../models';
+import type { AutoAutomationRun } from '../models';
 import type { AutoAutomationRunPage } from '../models';
 import type { AutoCatalog } from '../models';
 import type { AutoCreateFlowReq } from '../models';
@@ -26,6 +27,7 @@ import type { AutoFlowRun } from '../models';
 import type { AutoFlowVersion } from '../models';
 import type { AutoPatchFlowIn } from '../models';
 import type { AutoPopulatedFlow } from '../models';
+import type { AutoReviewIn } from '../models';
 import type { AutoRunIn } from '../models';
 import type { AutoRunPage } from '../models';
 import type { AutoRunResp } from '../models';
@@ -169,6 +171,16 @@ export declare const AutoApiAxiosParamCreator: (configuration?: Configuration) =
      * @throws {RequiredError}
      */
     postAutoAutomationsByIdRun: (id: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {string} id ID is the automation, and Run its run in review, from the path.
+     * @param {string} run
+     * @param {AutoReviewIn} autoReviewIn
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postAutoAutomationsByIdRunsByRunReview: (id: string, run: string, autoReviewIn: AutoReviewIn, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.
@@ -382,6 +394,16 @@ export declare const AutoApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     postAutoAutomationsByIdRun(id: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AutoRunStarted>>;
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {string} id ID is the automation, and Run its run in review, from the path.
+     * @param {string} run
+     * @param {AutoReviewIn} autoReviewIn
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postAutoAutomationsByIdRunsByRunReview(id: string, run: string, autoReviewIn: AutoReviewIn, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<AutoAutomationRun>>;
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.
@@ -589,6 +611,14 @@ export declare const AutoApiFactory: (configuration?: Configuration, basePath?:
      * @throws {RequiredError}
      */
     postAutoAutomationsByIdRun(requestParameters: AutoApiPostAutoAutomationsByIdRunRequest, options?: RawAxiosRequestConfig): AxiosPromise<AutoRunStarted>;
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postAutoAutomationsByIdRunsByRunReview(requestParameters: AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest, options?: RawAxiosRequestConfig): AxiosPromise<AutoAutomationRun>;
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.
@@ -880,6 +910,31 @@ export interface AutoApiPostAutoAutomationsByIdRunRequest {
      */
     readonly id: string;
 }
+/**
+ * Request parameters for postAutoAutomationsByIdRunsByRunReview operation in AutoApi.
+ * @export
+ * @interface AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest
+ */
+export interface AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest {
+    /**
+     * ID is the automation, and Run its run in review, from the path.
+     * @type {string}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly id: string;
+    /**
+     *
+     * @type {string}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly run: string;
+    /**
+     *
+     * @type {AutoReviewIn}
+     * @memberof AutoApiPostAutoAutomationsByIdRunsByRunReview
+     */
+    readonly autoReviewIn: AutoReviewIn;
+}
 /**
  * Request parameters for postAutoFlows operation in AutoApi.
  * @export
@@ -1164,6 +1219,15 @@ export declare class AutoApi extends BaseAPI {
      * @memberof AutoApi
      */
     postAutoAutomationsByIdRun(requestParameters: AutoApiPostAutoAutomationsByIdRunRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AutoRunStarted, any, {}>>;
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AutoApi
+     */
+    postAutoAutomationsByIdRunsByRunReview(requestParameters: AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<AutoAutomationRun, any, {}>>;
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.

package/dist/esm/api/auto-api.js

@@ -554,6 +554,47 @@ export const AutoApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {string} id ID is the automation, and Run its run in review, from the path.
+         * @param {string} run
+         * @param {AutoReviewIn} autoReviewIn
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postAutoAutomationsByIdRunsByRunReview: async (id, run, autoReviewIn, options = {}) => {
+            // verify required parameter 'id' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'id', id);
+            // verify required parameter 'run' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'run', run);
+            // verify required parameter 'autoReviewIn' is not null or undefined
+            assertParamExists('postAutoAutomationsByIdRunsByRunReview', 'autoReviewIn', autoReviewIn);
+            const localVarPath = `/v1/auto/automations/{id}/runs/{run}/review`
+                .replace(`{${"id"}}`, encodeURIComponent(String(id)))
+                .replace(`{${"run"}}`, encodeURIComponent(String(run)));
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            localVarHeaderParameter['Content-Type'] = 'application/json';
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            localVarRequestOptions.data = serializeDataIfNeeded(autoReviewIn, localVarRequestOptions, configuration);
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1078,6 +1119,21 @@ export const AutoApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['AutoApi.postAutoAutomationsByIdRun']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {string} id ID is the automation, and Run its run in review, from the path.
+         * @param {string} run
+         * @param {AutoReviewIn} autoReviewIn
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postAutoAutomationsByIdRunsByRunReview(id, run, autoReviewIn, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postAutoAutomationsByIdRunsByRunReview(id, run, autoReviewIn, options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['AutoApi.postAutoAutomationsByIdRunsByRunReview']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1365,6 +1421,16 @@ export const AutoApiFactory = function (configuration, basePath, axios) {
         postAutoAutomationsByIdRun(requestParameters, options) {
             return localVarFp.postAutoAutomationsByIdRun(requestParameters.id, options).then((request) => request(axios, basePath));
         },
+        /**
+         * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+         * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+         * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postAutoAutomationsByIdRunsByRunReview(requestParameters, options) {
+            return localVarFp.postAutoAutomationsByIdRunsByRunReview(requestParameters.id, requestParameters.run, requestParameters.autoReviewIn, options).then((request) => request(axios, basePath));
+        },
         /**
          * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
          * @summary Creates an automation and its initial DRAFT version in one call.
@@ -1638,6 +1704,17 @@ export class AutoApi extends BaseAPI {
     postAutoAutomationsByIdRun(requestParameters, options) {
         return AutoApiFp(this.configuration).postAutoAutomationsByIdRun(requestParameters.id, options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it. A run not in review answers 409; one held longer than a day is not posted.
+     * @summary Answers a run that holds a post for review, for the person the automation runs as or an admin of the org: `post` true posts it to the automation\'s accounts and answers the run while it posts; false discards it.
+     * @param {AutoApiPostAutoAutomationsByIdRunsByRunReviewRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AutoApi
+     */
+    postAutoAutomationsByIdRunsByRunReview(requestParameters, options) {
+        return AutoApiFp(this.configuration).postAutoAutomationsByIdRunsByRunReview(requestParameters.id, requestParameters.run, requestParameters.autoReviewIn, options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Creates an automation and its initial DRAFT version in one call. The new flow is DISABLED — creating it does not arm its trigger; POST /v1/auto/flows/{id}/enable does that.
      * @summary Creates an automation and its initial DRAFT version in one call.

package/dist/esm/api/billing-api.d.ts

@@ -129,7 +129,7 @@ export declare const BillingApiAxiosParamCreator: (configuration?: Configuration
      */
     getBillingAlertsAuthorize: (project?: string, service?: string, amount?: string, pv?: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -518,7 +518,7 @@ export declare const BillingApiFp: (configuration?: Configuration) => {
      */
     getBillingAlertsAuthorize(project?: string, service?: string, amount?: string, pv?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<BillingCapVerdict>>;
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -903,7 +903,7 @@ export declare const BillingApiFactory: (configuration?: Configuration, basePath
      */
     getBillingAlertsAuthorize(requestParameters?: BillingApiGetBillingAlertsAuthorizeRequest, options?: RawAxiosRequestConfig): AxiosPromise<BillingCapVerdict>;
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
@@ -1711,7 +1711,7 @@ export declare class BillingApi extends BaseAPI {
      */
     getBillingAlertsAuthorize(requestParameters?: BillingApiGetBillingAlertsAuthorizeRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<BillingCapVerdict, any, {}>>;
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/dist/esm/api/billing-api.js

@@ -321,7 +321,7 @@ export const BillingApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -1695,7 +1695,7 @@ export const BillingApiFp = function (configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2301,7 +2301,7 @@ export const BillingApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getBillingAlertsAuthorize(requestParameters.project, requestParameters.service, requestParameters.amount, requestParameters.pv, options).then((request) => request(axios, basePath));
         },
         /**
-         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+         * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
          * @summary Prepaid credit the caller\'s org can still spend
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -2786,7 +2786,7 @@ export class BillingApi extends BaseAPI {
         return BillingApiFp(this.configuration).getBillingAlertsAuthorize(requestParameters.project, requestParameters.service, requestParameters.amount, requestParameters.pv, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. Both pay for any call, and every debit draws cash first.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
+     * Answers the spendable prepaid balance of the wallet this caller bills from — the same wallet the AI prepaid gate reads before admitting a paid request, the edge meter debits, and a top-up credits.  The wallet is an ADDRESS, not an org: `account` echoes the key resolved within the ledger — the org\'s shared pool for a tenant org, a personal account for a member of the shared signup org. The echo is the point. A browser could only GUESS its own payer by decoding its own token, and a guess that disagrees with the server is how money lands in an account the gate never reads.  `balance`, `holds` and `available` are whole USD cents, ROUNDED from the ledger\'s exact 18-decimal value. On the co-resident ledger `holds` is 0 and `available` equals `balance`: the gate\'s reservations live in its own pod and are never posted, so the settled balance IS the spendable one.  `cash`, `line` and `credit` say where `available` came from, and add up to it. `cash` is money the customer paid — a settled card payment or a recorded wire. `credit` is money Hanzo minted: signup and promotional credit, admin grants. `line` is what is left of the org\'s postpaid credit line (`creditLimit`), and `due` what the account owes on it: usage the line paid for, invoiced, and paid down first by the next payment. A debit draws cash, then the line, then credit; granted credit never pays what is due. The three line fields are absent when the ledger did not report them.  The ledger is the caller\'s own org, taken from the VALIDATED IAM owner claim and never from a client header. No validated principal is 401. A balance that cannot be READ is 502, never 0: unknown is not broke.
      * @summary Prepaid credit the caller\'s org can still spend
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/dist/esm/api/git-api.d.ts

@@ -47,6 +47,7 @@ import type { GitUsageView } from '../models';
 import type { GitWorkflowList } from '../models';
 import type { GitWorkflowRun } from '../models';
 import type { GitWorkflowRuns } from '../models';
+import type { GitWorkspaceView } from '../models';
 import type { RunnerDeclareIn } from '../models';
 import type { RunnerDeclareOut } from '../models';
 import type { RunnerLogIn } from '../models';
@@ -460,6 +461,13 @@ export declare const GitApiAxiosParamCreator: (configuration?: Configuration) =>
      * @throws {RequiredError}
      */
     postGitWebhook: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postGitWorkspace: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -912,6 +920,13 @@ export declare const GitApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     postGitWebhook(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postGitWorkspace(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<GitWorkspaceView>>;
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -1326,6 +1341,13 @@ export declare const GitApiFactory: (configuration?: Configuration, basePath?: s
      * @throws {RequiredError}
      */
     postGitWebhook(options?: RawAxiosRequestConfig): AxiosPromise<void>;
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    postGitWorkspace(options?: RawAxiosRequestConfig): AxiosPromise<GitWorkspaceView>;
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -2615,6 +2637,14 @@ export declare class GitApi extends BaseAPI {
      * @memberof GitApi
      */
     postGitWebhook(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<void, any, {}>>;
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof GitApi
+     */
+    postGitWorkspace(options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<GitWorkspaceView, any, {}>>;
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.

package/dist/esm/api/git-api.js

@@ -1621,6 +1621,34 @@ export const GitApiAxiosParamCreator = function (configuration) {
                 options: localVarRequestOptions,
             };
         },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postGitWorkspace: async (options = {}) => {
+            const localVarPath = `/v1/git/workspace`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication bearer required
+            // http bearer authentication required
+            await setBearerAuthToObject(localVarHeaderParameter, configuration);
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
         /**
          * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
          * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -2455,6 +2483,18 @@ export const GitApiFp = function (configuration) {
             const localVarOperationServerBasePath = operationServerMap['GitApi.postGitWebhook']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postGitWorkspace(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postGitWorkspace(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['GitApi.postGitWorkspace']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
          * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -2989,6 +3029,15 @@ export const GitApiFactory = function (configuration, basePath, axios) {
         postGitWebhook(options) {
             return localVarFp.postGitWebhook(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+         * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postGitWorkspace(options) {
+            return localVarFp.postGitWorkspace(options).then((request) => request(axios, basePath));
+        },
         /**
          * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
          * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
@@ -3546,6 +3595,16 @@ export class GitApi extends BaseAPI {
     postGitWebhook(options) {
         return GitApiFp(this.configuration).postGitWebhook(options).then((request) => request(this.axios, this.basePath));
     }
+    /**
+     * Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there. Idempotent. The estate\'s namespace is answered from the closed table and nobody is enrolled in it. A seat is a person\'s: an API key or an application is refused, and a SuperAdmin acting in another org reads the workspace as it is and makes nothing.
+     * @summary Sets the org\'s code workspace up for the caller and answers it: the namespace, made when the org has none, and the caller\'s forge account and seat there.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof GitApi
+     */
+    postGitWorkspace(options) {
+        return GitApiFp(this.configuration).postGitWorkspace(options).then((request) => request(this.axios, this.basePath));
+    }
     /**
      * Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.
      * @summary Republishes what a registered runner can do, and answers with what this side understands, so the two learn about each other from one exchange.

package/dist/esm/api/task-api.d.ts

@@ -13,6 +13,7 @@ import type { Configuration } from '../configuration';
 import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
 import { type RequestArgs, BaseAPI } from '../base';
 import type { TaskBoardView } from '../models';
+import type { TaskCommentList } from '../models';
 import type { TaskIssueEdit } from '../models';
 import type { TaskIssueHit } from '../models';
 import type { TaskIssueHits } from '../models';
@@ -100,6 +101,15 @@ export declare const TaskApiAxiosParamCreator: (configuration?: Configuration) =
      * @throws {RequiredError}
      */
     getTaskProjectsByKeyIssuesByNum: (key: string, num: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    /**
+     * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+     * @summary Is one issue\'s conversation, oldest first, read as the caller.
+     * @param {string} key Key is the board — the repository name, or an index board\&#39;s key.
+     * @param {number} num Num is the issue\&#39;s number on that board.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getTaskProjectsByKeyIssuesByNumComments: (key: string, num: number, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
      * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
      * @summary Summarises one room\'s work.
@@ -233,6 +243,15 @@ export declare const TaskApiFp: (configuration?: Configuration) => {
      * @throws {RequiredError}
      */
     getTaskProjectsByKeyIssuesByNum(key: string, num: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TaskIssueView>>;
+    /**
+     * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+     * @summary Is one issue\'s conversation, oldest first, read as the caller.
+     * @param {string} key Key is the board — the repository name, or an index board\&#39;s key.
+     * @param {number} num Num is the issue\&#39;s number on that board.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getTaskProjectsByKeyIssuesByNumComments(key: string, num: number, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TaskCommentList>>;
     /**
      * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
      * @summary Summarises one room\'s work.
@@ -345,6 +364,14 @@ export declare const TaskApiFactory: (configuration?: Configuration, basePath?:
      * @throws {RequiredError}
      */
     getTaskProjectsByKeyIssuesByNum(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumRequest, options?: RawAxiosRequestConfig): AxiosPromise<TaskIssueView>;
+    /**
+     * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+     * @summary Is one issue\'s conversation, oldest first, read as the caller.
+     * @param {TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getTaskProjectsByKeyIssuesByNumComments(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest, options?: RawAxiosRequestConfig): AxiosPromise<TaskCommentList>;
     /**
      * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
      * @summary Summarises one room\'s work.
@@ -597,6 +624,25 @@ export interface TaskApiGetTaskProjectsByKeyIssuesByNumRequest {
      */
     readonly num: number;
 }
+/**
+ * Request parameters for getTaskProjectsByKeyIssuesByNumComments operation in TaskApi.
+ * @export
+ * @interface TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest
+ */
+export interface TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest {
+    /**
+     * Key is the board — the repository name, or an index board\&#39;s key.
+     * @type {string}
+     * @memberof TaskApiGetTaskProjectsByKeyIssuesByNumComments
+     */
+    readonly key: string;
+    /**
+     * Num is the issue\&#39;s number on that board.
+     * @type {number}
+     * @memberof TaskApiGetTaskProjectsByKeyIssuesByNumComments
+     */
+    readonly num: number;
+}
 /**
  * Request parameters for getTaskRoomsByRoom operation in TaskApi.
  * @export
@@ -755,6 +801,15 @@ export declare class TaskApi extends BaseAPI {
      * @memberof TaskApi
      */
     getTaskProjectsByKeyIssuesByNum(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<TaskIssueView, any, {}>>;
+    /**
+     * Is one issue\'s conversation, oldest first, read as the caller. An issue that lives on GitHub names its home and is read there.
+     * @summary Is one issue\'s conversation, oldest first, read as the caller.
+     * @param {TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest} requestParameters Request parameters.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof TaskApi
+     */
+    getTaskProjectsByKeyIssuesByNumComments(requestParameters: TaskApiGetTaskProjectsByKeyIssuesByNumCommentsRequest, options?: RawAxiosRequestConfig): Promise<import("axios").AxiosResponse<TaskCommentList, any, {}>>;
     /**
      * Summarises one room\'s work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal\'s org and nothing else, so a caller cannot read another tenant\'s channel by naming its room.
      * @summary Summarises one room\'s work.