@knowledge-stack/ksapi 1.163.0 → 2.4.2

package/dist/esm/apis/TrashApi.js

@@ -21,7 +21,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
-import { BulkOperationResponseFromJSON, BulkTrashRequestToJSON, PaginatedResponseTrashItemResponseFromJSON, } from '../models/index';
+import { BulkOperationResponseFromJSON, BulkTrashRequestToJSON, PaginatedResponseTrashItemResponseFromJSON, TrashItemDetailResponseFromJSON, } from '../models/index';
 /**
  *
  */
@@ -124,6 +124,54 @@ export class TrashApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getTrashItem without sending the request
+     */
+    getTrashItemRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['pathPartId'] == null) {
+                throw new runtime.RequiredError('pathPartId', 'Required parameter "pathPartId" was null or undefined when calling getTrashItem().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            let urlPath = `/v1/trash/{path_part_id}`;
+            urlPath = urlPath.replace(`{${"path_part_id"}}`, encodeURIComponent(String(requestParameters['pathPartId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Fetch a single trash root, with a preview URL for DOCUMENT items.
+     * Get Trash Item Handler
+     */
+    getTrashItemRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getTrashItemRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => TrashItemDetailResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Fetch a single trash root, with a preview URL for DOCUMENT items.
+     * Get Trash Item Handler
+     */
+    getTrashItem(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getTrashItemRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for listTrash without sending the request
      */

package/dist/esm/apis/WorkflowRunsApi.d.ts

@@ -356,7 +356,7 @@ export interface WorkflowRunsApiInterface {
      */
     workflowRunCallbackRequestOpts(requestParameters: WorkflowRunCallbackOperationRequest): Promise<runtime.RequestOpts>;
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * @summary Workflow Run Callback Handler
      * @param {string} runId
      * @param {WorkflowRunCallbackRequest} workflowRunCallbackRequest
@@ -366,7 +366,7 @@ export interface WorkflowRunsApiInterface {
      */
     workflowRunCallbackRaw(requestParameters: WorkflowRunCallbackOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowCallbackResponse>>;
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * Workflow Run Callback Handler
      */
     workflowRunCallback(requestParameters: WorkflowRunCallbackOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowCallbackResponse>;
@@ -530,12 +530,12 @@ export declare class WorkflowRunsApi extends runtime.BaseAPI implements Workflow
      */
     workflowRunCallbackRequestOpts(requestParameters: WorkflowRunCallbackOperationRequest): Promise<runtime.RequestOpts>;
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * Workflow Run Callback Handler
      */
     workflowRunCallbackRaw(requestParameters: WorkflowRunCallbackOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<WorkflowCallbackResponse>>;
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * Workflow Run Callback Handler
      */
     workflowRunCallback(requestParameters: WorkflowRunCallbackOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<WorkflowCallbackResponse>;

package/dist/esm/apis/WorkflowRunsApi.js

@@ -648,7 +648,7 @@ export class WorkflowRunsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * Workflow Run Callback Handler
      */
     workflowRunCallbackRaw(requestParameters, initOverrides) {
@@ -659,7 +659,7 @@ export class WorkflowRunsApi extends runtime.BaseAPI {
         });
     }
     /**
-     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.
+     * Terminal-state write seam for the in-process agent runner.  The gating Temporal activities ``mark_run_completed_activity`` and ``mark_run_failed_activity`` authenticate as the triggering user (via ``assume_user``) and POST here. Only the user who triggered the run (or OWNER/ADMIN) may write its terminal state. The handler is idempotent: a callback against an already-terminal row returns ``already_terminal`` and the activity-level retry treats it as a no-op.  On the first terminal transition it emails the run\'s triggering user (``run.user_id``) a completion or failure notification. Only already-loaded columns are captured in-session; recipient/language lookups and the send run post-commit and best-effort, so a rolled-back transaction never notifies and a notification failure never fails the callback.
      * Workflow Run Callback Handler
      */
     workflowRunCallback(requestParameters, initOverrides) {

package/dist/esm/apis/index.d.ts

@@ -5,6 +5,7 @@ export * from './ApiConnectionsApi';
 export * from './ApiKeysApi';
 export * from './AuditEventsApi';
 export * from './AuthApi';
+export * from './BillingApi';
 export * from './BulkDeleteApi';
 export * from './BulkDownloadApi';
 export * from './BulkMoveApi';

package/dist/esm/apis/index.js

@@ -7,6 +7,7 @@ export * from './ApiConnectionsApi';
 export * from './ApiKeysApi';
 export * from './AuditEventsApi';
 export * from './AuthApi';
+export * from './BillingApi';
 export * from './BulkDeleteApi';
 export * from './BulkDownloadApi';
 export * from './BulkMoveApi';

package/dist/esm/models/BillingInterval.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Self-serve billing period length.
+ * @export
+ */
+export declare const BillingInterval: {
+    readonly Monthly: 'MONTHLY';
+    readonly Annual: 'ANNUAL';
+};
+export type BillingInterval = typeof BillingInterval[keyof typeof BillingInterval];
+export declare function instanceOfBillingInterval(value: any): boolean;
+export declare function BillingIntervalFromJSON(json: any): BillingInterval;
+export declare function BillingIntervalFromJSONTyped(json: any, ignoreDiscriminator: boolean): BillingInterval;
+export declare function BillingIntervalToJSON(value?: BillingInterval | null): any;
+export declare function BillingIntervalToJSONTyped(value: any, ignoreDiscriminator: boolean): BillingInterval;

package/dist/esm/models/BillingInterval.js

@@ -0,0 +1,43 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Self-serve billing period length.
+ * @export
+ */
+export const BillingInterval = {
+    Monthly: 'MONTHLY',
+    Annual: 'ANNUAL'
+};
+export function instanceOfBillingInterval(value) {
+    for (const key in BillingInterval) {
+        if (Object.prototype.hasOwnProperty.call(BillingInterval, key)) {
+            if (BillingInterval[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function BillingIntervalFromJSON(json) {
+    return BillingIntervalFromJSONTyped(json, false);
+}
+export function BillingIntervalFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+export function BillingIntervalToJSON(value) {
+    return value;
+}
+export function BillingIntervalToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}

package/dist/esm/models/BillingPaymentResponse.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { BillingSystem } from './BillingSystem';
+/**
+ * One confirmed payment, as shown in the tenant's billing history.
+ *
+ * Backs in-app receipts: CN payments have no provider-hosted invoice
+ * (``invoice_url`` is NULL) — the frontend renders a receipt from
+ * these fields. Stripe payments link the hosted invoice.
+ * @export
+ * @interface BillingPaymentResponse
+ */
+export interface BillingPaymentResponse {
+    /**
+     * Payment id.
+     * @type {string}
+     * @memberof BillingPaymentResponse
+     */
+    id: string;
+    /**
+     *
+     * @type {BillingSystem}
+     * @memberof BillingPaymentResponse
+     */
+    billingSystem: BillingSystem;
+    /**
+     * Plan purchased.
+     * @type {string}
+     * @memberof BillingPaymentResponse
+     */
+    planId: string;
+    /**
+     * Billing period purchased.
+     * @type {string}
+     * @memberof BillingPaymentResponse
+     */
+    interval: string;
+    /**
+     * Seats purchased.
+     * @type {number}
+     * @memberof BillingPaymentResponse
+     */
+    numSeats: number;
+    /**
+     * Total charged, in the currency's minor unit.
+     * @type {number}
+     * @memberof BillingPaymentResponse
+     */
+    amount: number;
+    /**
+     * USD (cents) or CNY (fen).
+     * @type {string}
+     * @memberof BillingPaymentResponse
+     */
+    currency: string;
+    /**
+     * Provider-hosted invoice/receipt, when available.
+     * @type {string}
+     * @memberof BillingPaymentResponse
+     */
+    invoiceUrl?: string | null;
+    /**
+     * When the payment confirmed.
+     * @type {Date}
+     * @memberof BillingPaymentResponse
+     */
+    createdAt: Date;
+}
+export declare const BillingPaymentResponsePropertyValidationAttributesMap: {
+    [property: string]: {
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maximum?: number;
+        exclusiveMaximum?: boolean;
+        minimum?: number;
+        exclusiveMinimum?: boolean;
+        multipleOf?: number;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+    };
+};
+/**
+ * Check if a given object implements the BillingPaymentResponse interface.
+ */
+export declare function instanceOfBillingPaymentResponse(value: object): value is BillingPaymentResponse;
+export declare function BillingPaymentResponseFromJSON(json: any): BillingPaymentResponse;
+export declare function BillingPaymentResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): BillingPaymentResponse;
+export declare function BillingPaymentResponseToJSON(json: any): BillingPaymentResponse;
+export declare function BillingPaymentResponseToJSONTyped(value?: BillingPaymentResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/BillingPaymentResponse.js

@@ -0,0 +1,75 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { BillingSystemFromJSON, BillingSystemToJSON, } from './BillingSystem';
+export const BillingPaymentResponsePropertyValidationAttributesMap = {};
+/**
+ * Check if a given object implements the BillingPaymentResponse interface.
+ */
+export function instanceOfBillingPaymentResponse(value) {
+    if (!('id' in value) || value['id'] === undefined)
+        return false;
+    if (!('billingSystem' in value) || value['billingSystem'] === undefined)
+        return false;
+    if (!('planId' in value) || value['planId'] === undefined)
+        return false;
+    if (!('interval' in value) || value['interval'] === undefined)
+        return false;
+    if (!('numSeats' in value) || value['numSeats'] === undefined)
+        return false;
+    if (!('amount' in value) || value['amount'] === undefined)
+        return false;
+    if (!('currency' in value) || value['currency'] === undefined)
+        return false;
+    if (!('createdAt' in value) || value['createdAt'] === undefined)
+        return false;
+    return true;
+}
+export function BillingPaymentResponseFromJSON(json) {
+    return BillingPaymentResponseFromJSONTyped(json, false);
+}
+export function BillingPaymentResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'id': json['id'],
+        'billingSystem': BillingSystemFromJSON(json['billing_system']),
+        'planId': json['plan_id'],
+        'interval': json['interval'],
+        'numSeats': json['num_seats'],
+        'amount': json['amount'],
+        'currency': json['currency'],
+        'invoiceUrl': json['invoice_url'] == null ? undefined : json['invoice_url'],
+        'createdAt': (new Date(json['created_at'])),
+    };
+}
+export function BillingPaymentResponseToJSON(json) {
+    return BillingPaymentResponseToJSONTyped(json, false);
+}
+export function BillingPaymentResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'id': value['id'],
+        'billing_system': BillingSystemToJSON(value['billingSystem']),
+        'plan_id': value['planId'],
+        'interval': value['interval'],
+        'num_seats': value['numSeats'],
+        'amount': value['amount'],
+        'currency': value['currency'],
+        'invoice_url': value['invoiceUrl'],
+        'created_at': value['createdAt'].toISOString(),
+    };
+}

package/dist/esm/models/BillingSystem.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * External payment platform a subscription or payment is linked to.
+ *
+ * ``STRIPE`` serves North America; ``PING_PP`` (Ping++, a mainland-China
+ * payment aggregator fronting Alipay + WeChat Pay) serves China. Rows
+ * with no external billing linkage (free / admin-issued / synthetic
+ * fall-back subscriptions) carry NULL instead of a value.
+ * @export
+ */
+export declare const BillingSystem: {
+    readonly Stripe: 'STRIPE';
+    readonly PingPp: 'PING_PP';
+};
+export type BillingSystem = typeof BillingSystem[keyof typeof BillingSystem];
+export declare function instanceOfBillingSystem(value: any): boolean;
+export declare function BillingSystemFromJSON(json: any): BillingSystem;
+export declare function BillingSystemFromJSONTyped(json: any, ignoreDiscriminator: boolean): BillingSystem;
+export declare function BillingSystemToJSON(value?: BillingSystem | null): any;
+export declare function BillingSystemToJSONTyped(value: any, ignoreDiscriminator: boolean): BillingSystem;

package/dist/esm/models/BillingSystem.js

@@ -0,0 +1,48 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * External payment platform a subscription or payment is linked to.
+ *
+ * ``STRIPE`` serves North America; ``PING_PP`` (Ping++, a mainland-China
+ * payment aggregator fronting Alipay + WeChat Pay) serves China. Rows
+ * with no external billing linkage (free / admin-issued / synthetic
+ * fall-back subscriptions) carry NULL instead of a value.
+ * @export
+ */
+export const BillingSystem = {
+    Stripe: 'STRIPE',
+    PingPp: 'PING_PP'
+};
+export function instanceOfBillingSystem(value) {
+    for (const key in BillingSystem) {
+        if (Object.prototype.hasOwnProperty.call(BillingSystem, key)) {
+            if (BillingSystem[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function BillingSystemFromJSON(json) {
+    return BillingSystemFromJSONTyped(json, false);
+}
+export function BillingSystemFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+export function BillingSystemToJSON(value) {
+    return value;
+}
+export function BillingSystemToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}

package/dist/esm/models/ChangeSubscriptionRequest.d.ts

@@ -9,8 +9,16 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import type { BillingInterval } from './BillingInterval';
+import type { BillingSystem } from './BillingSystem';
 /**
  * Body for ``POST /v1/tenants/{tenant_id}/subscriptions``.
+ *
+ * For a priced plan, ``interval`` and ``billing_system`` are required
+ * (``channel`` too for Ping++); the response carries the provider
+ * checkout to complete. For the free plan they are ignored — the
+ * downgrade is applied immediately (unbilled tenants) or scheduled
+ * for period end (billed tenants).
  * @export
  * @interface ChangeSubscriptionRequest
  */
@@ -27,6 +35,32 @@ export interface ChangeSubscriptionRequest {
      * @memberof ChangeSubscriptionRequest
      */
     numSeats: number;
+    /**
+     *
+     * @type {BillingInterval}
+     * @memberof ChangeSubscriptionRequest
+     */
+    interval?: BillingInterval;
+    /**
+     *
+     * @type {BillingSystem}
+     * @memberof ChangeSubscriptionRequest
+     */
+    billingSystem?: BillingSystem;
+    /**
+     * Ping++ payment channel chosen in the UI (e.g. 'alipay_pc_direct', 'wx_pub_qr'). Required when billing_system=PING_PP.
+     * @type {string}
+     * @memberof ChangeSubscriptionRequest
+     */
+    channel?: string | null;
+    /**
+     * Channel-specific Ping++ charge `extra` parameters (success_url, product ids, ... — see the Ping++ charge API for the chosen channel). Passed through verbatim; amounts are always resolved server-side.
+     * @type {{ [key: string]: any; }}
+     * @memberof ChangeSubscriptionRequest
+     */
+    channelExtra?: {
+        [key: string]: any;
+    } | null;
 }
 export declare const ChangeSubscriptionRequestPropertyValidationAttributesMap: {
     [property: string]: {

package/dist/esm/models/ChangeSubscriptionRequest.js

@@ -11,6 +11,8 @@
  * https://openapi-generator.tech
  * Do not edit the class manually.
  */
+import { BillingIntervalFromJSON, BillingIntervalToJSON, } from './BillingInterval';
+import { BillingSystemFromJSON, BillingSystemToJSON, } from './BillingSystem';
 export const ChangeSubscriptionRequestPropertyValidationAttributesMap = {
     numSeats: {
         minimum: 1,
@@ -37,6 +39,10 @@ export function ChangeSubscriptionRequestFromJSONTyped(json, ignoreDiscriminator
     return {
         'subscriptionId': json['subscription_id'],
         'numSeats': json['num_seats'],
+        'interval': json['interval'] == null ? undefined : BillingIntervalFromJSON(json['interval']),
+        'billingSystem': json['billing_system'] == null ? undefined : BillingSystemFromJSON(json['billing_system']),
+        'channel': json['channel'] == null ? undefined : json['channel'],
+        'channelExtra': json['channel_extra'] == null ? undefined : json['channel_extra'],
     };
 }
 export function ChangeSubscriptionRequestToJSON(json) {
@@ -49,5 +55,9 @@ export function ChangeSubscriptionRequestToJSONTyped(value, ignoreDiscriminator
     return {
         'subscription_id': value['subscriptionId'],
         'num_seats': value['numSeats'],
+        'interval': BillingIntervalToJSON(value['interval']),
+        'billing_system': BillingSystemToJSON(value['billingSystem']),
+        'channel': value['channel'],
+        'channel_extra': value['channelExtra'],
     };
 }

package/dist/esm/models/CheckoutAction.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * What the client must do next after a subscription-change request.
+ * @export
+ */
+export declare const CheckoutAction: {
+    readonly Redirect: 'REDIRECT';
+    readonly Credential: 'CREDENTIAL';
+    readonly Scheduled: 'SCHEDULED';
+    readonly Applied: 'APPLIED';
+};
+export type CheckoutAction = typeof CheckoutAction[keyof typeof CheckoutAction];
+export declare function instanceOfCheckoutAction(value: any): boolean;
+export declare function CheckoutActionFromJSON(json: any): CheckoutAction;
+export declare function CheckoutActionFromJSONTyped(json: any, ignoreDiscriminator: boolean): CheckoutAction;
+export declare function CheckoutActionToJSON(value?: CheckoutAction | null): any;
+export declare function CheckoutActionToJSONTyped(value: any, ignoreDiscriminator: boolean): CheckoutAction;

package/dist/esm/models/CheckoutAction.js

@@ -0,0 +1,45 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Knowledge Stack API
+ * Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user\'s live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema\'s `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call.
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * What the client must do next after a subscription-change request.
+ * @export
+ */
+export const CheckoutAction = {
+    Redirect: 'REDIRECT',
+    Credential: 'CREDENTIAL',
+    Scheduled: 'SCHEDULED',
+    Applied: 'APPLIED'
+};
+export function instanceOfCheckoutAction(value) {
+    for (const key in CheckoutAction) {
+        if (Object.prototype.hasOwnProperty.call(CheckoutAction, key)) {
+            if (CheckoutAction[key] === value) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function CheckoutActionFromJSON(json) {
+    return CheckoutActionFromJSONTyped(json, false);
+}
+export function CheckoutActionFromJSONTyped(json, ignoreDiscriminator) {
+    return json;
+}
+export function CheckoutActionToJSON(value) {
+    return value;
+}
+export function CheckoutActionToJSONTyped(value, ignoreDiscriminator) {
+    return value;
+}