hanzoai 2.2.10 → 8.5.89

package/src/api/billing-api.ts

@@ -386,6 +386,40 @@ export const BillingApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Returns the same balance /v1/billing/credit-balance reports, split by the tag each grant carries, so a reader can tell trial credit from bought credit and show the earliest expiry within each group. A console needs the split to say what will lapse and when; the single number cannot.  The subject is pinned to the caller before the handler runs, exactly as in the sibling reads, so the userId parameter can never name another tenant. A subject with no grants is an empty breakdown and a zero total, which is an answer and not an error.
+         * @summary What is left of your credit, grouped by where it came from
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBillingCreditBalanceBreakdown: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/v1/billing/credit-balance/breakdown`;
+            // 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: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // 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};
@@ -904,6 +938,40 @@ export const BillingApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Answers the one read the account page renders: the subject\'s resolved plan, the plan\'s included monthly allotment beside what was actually granted this period, consumption capped at that grant, the overage past it, and the spendable wallet (balance minus holds) — all for the current UTC month, every figure derived from the same transactions the gateway\'s balance gate reads, so this read can never disagree with the gate that admits the next call. It rides the same pinned chain as the sibling reads: the user parameter is overwritten with the validated caller\'s own billing subject before the handler runs, so it can never name another tenant; user is required, which only a service-to-service caller can omit and be refused 400 for, and plan is optional — omitted, it is resolved from the subject\'s subscription. The rule to get right is that the two sides are DIFFERENT MONEY: the included figures are usage the subscription grants and the wallet is prepaid credit the customer bought, so a reader who sums them invents a balance nobody holds — and before the period\'s first allotment grant runs, monthlyCents shows the plan\'s entitlement while grantedCents is zero, which is the figure consumption actually draws down.
+         * @summary What plan you are on and how much of it is left, beside the wallet
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBillingUsageRollup: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/v1/billing/usage/rollup`;
+            // 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: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // 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};
@@ -1694,6 +1762,18 @@ export const BillingApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['BillingApi.getBillingCreditBalance']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Returns the same balance /v1/billing/credit-balance reports, split by the tag each grant carries, so a reader can tell trial credit from bought credit and show the earliest expiry within each group. A console needs the split to say what will lapse and when; the single number cannot.  The subject is pinned to the caller before the handler runs, exactly as in the sibling reads, so the userId parameter can never name another tenant. A subject with no grants is an empty breakdown and a zero total, which is an answer and not an error.
+         * @summary What is left of your credit, grouped by where it came from
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getBillingCreditBalanceBreakdown(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getBillingCreditBalanceBreakdown(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BillingApi.getBillingCreditBalanceBreakdown']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Returns the caller org\'s credit grants — each with its original amount, what remains and when it expires — so a customer can see what was given and what is left before metered spend draws it down. It is a READ of the caller\'s own subject, pinned before the handler runs, so a grant belonging to another tenant is simply absent. Granting credit is not this route and never has been: minting lands on the mint-gated POST /v1/billing/credit, which no browser can reach. Reading an empty balance is an empty array, not an error.
          * @summary List the credit grants on your org\'s balance
@@ -1876,6 +1956,18 @@ export const BillingApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['BillingApi.getBillingUsageAccounts']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Answers the one read the account page renders: the subject\'s resolved plan, the plan\'s included monthly allotment beside what was actually granted this period, consumption capped at that grant, the overage past it, and the spendable wallet (balance minus holds) — all for the current UTC month, every figure derived from the same transactions the gateway\'s balance gate reads, so this read can never disagree with the gate that admits the next call. It rides the same pinned chain as the sibling reads: the user parameter is overwritten with the validated caller\'s own billing subject before the handler runs, so it can never name another tenant; user is required, which only a service-to-service caller can omit and be refused 400 for, and plan is optional — omitted, it is resolved from the subject\'s subscription. The rule to get right is that the two sides are DIFFERENT MONEY: the included figures are usage the subscription grants and the wallet is prepaid credit the customer bought, so a reader who sums them invents a balance nobody holds — and before the period\'s first allotment grant runs, monthlyCents shows the plan\'s entitlement while grantedCents is zero, which is the figure consumption actually draws down.
+         * @summary What plan you are on and how much of it is left, beside the wallet
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getBillingUsageRollup(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getBillingUsageRollup(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['BillingApi.getBillingUsageRollup']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Answers the receiving bank details for the brand this deployment serves — the account the funds actually land in, hydrated per brand rather than hard-coded — together with the payment reference to put on the transfer.  THE REFERENCE IS THE POINT. It carries your own billing key, and it is how an arriving wire is attributed to your account; a transfer sent without it arrives as an unidentified receipt. That is why this read is gated at all: an unpinned caller would be handed an unattributable reference.  Reading it credits nothing and reserves nothing. A wire is settled by an operator when the bank shows the funds, so the balance moves on receipt, not on this call.
          * @summary Where to wire funds, and the reference that credits them to you
@@ -2205,6 +2297,15 @@ export const BillingApiFactory = function (configuration?: Configuration, basePa
         getBillingCreditBalance(options?: RawAxiosRequestConfig): AxiosPromise<void> {
             return localVarFp.getBillingCreditBalance(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Returns the same balance /v1/billing/credit-balance reports, split by the tag each grant carries, so a reader can tell trial credit from bought credit and show the earliest expiry within each group. A console needs the split to say what will lapse and when; the single number cannot.  The subject is pinned to the caller before the handler runs, exactly as in the sibling reads, so the userId parameter can never name another tenant. A subject with no grants is an empty breakdown and a zero total, which is an answer and not an error.
+         * @summary What is left of your credit, grouped by where it came from
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBillingCreditBalanceBreakdown(options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.getBillingCreditBalanceBreakdown(options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns the caller org\'s credit grants — each with its original amount, what remains and when it expires — so a customer can see what was given and what is left before metered spend draws it down. It is a READ of the caller\'s own subject, pinned before the handler runs, so a grant belonging to another tenant is simply absent. Granting credit is not this route and never has been: minting lands on the mint-gated POST /v1/billing/credit, which no browser can reach. Reading an empty balance is an empty array, not an error.
          * @summary List the credit grants on your org\'s balance
@@ -2342,6 +2443,15 @@ export const BillingApiFactory = function (configuration?: Configuration, basePa
         getBillingUsageAccounts(options?: RawAxiosRequestConfig): AxiosPromise<Accounts> {
             return localVarFp.getBillingUsageAccounts(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Answers the one read the account page renders: the subject\'s resolved plan, the plan\'s included monthly allotment beside what was actually granted this period, consumption capped at that grant, the overage past it, and the spendable wallet (balance minus holds) — all for the current UTC month, every figure derived from the same transactions the gateway\'s balance gate reads, so this read can never disagree with the gate that admits the next call. It rides the same pinned chain as the sibling reads: the user parameter is overwritten with the validated caller\'s own billing subject before the handler runs, so it can never name another tenant; user is required, which only a service-to-service caller can omit and be refused 400 for, and plan is optional — omitted, it is resolved from the subject\'s subscription. The rule to get right is that the two sides are DIFFERENT MONEY: the included figures are usage the subscription grants and the wallet is prepaid credit the customer bought, so a reader who sums them invents a balance nobody holds — and before the period\'s first allotment grant runs, monthlyCents shows the plan\'s entitlement while grantedCents is zero, which is the figure consumption actually draws down.
+         * @summary What plan you are on and how much of it is left, beside the wallet
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getBillingUsageRollup(options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.getBillingUsageRollup(options).then((request) => request(axios, basePath));
+        },
         /**
          * Answers the receiving bank details for the brand this deployment serves — the account the funds actually land in, hydrated per brand rather than hard-coded — together with the payment reference to put on the transfer.  THE REFERENCE IS THE POINT. It carries your own billing key, and it is how an arriving wire is attributed to your account; a transfer sent without it arrives as an unidentified receipt. That is why this read is gated at all: an unpinned caller would be handed an unattributable reference.  Reading it credits nothing and reserves nothing. A wire is settled by an operator when the bank shows the funds, so the balance moves on receipt, not on this call.
          * @summary Where to wire funds, and the reference that credits them to you
@@ -2847,6 +2957,17 @@ export class BillingApi extends BaseAPI {
         return BillingApiFp(this.configuration).getBillingCreditBalance(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Returns the same balance /v1/billing/credit-balance reports, split by the tag each grant carries, so a reader can tell trial credit from bought credit and show the earliest expiry within each group. A console needs the split to say what will lapse and when; the single number cannot.  The subject is pinned to the caller before the handler runs, exactly as in the sibling reads, so the userId parameter can never name another tenant. A subject with no grants is an empty breakdown and a zero total, which is an answer and not an error.
+     * @summary What is left of your credit, grouped by where it came from
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BillingApi
+     */
+    public getBillingCreditBalanceBreakdown(options?: RawAxiosRequestConfig) {
+        return BillingApiFp(this.configuration).getBillingCreditBalanceBreakdown(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Returns the caller org\'s credit grants — each with its original amount, what remains and when it expires — so a customer can see what was given and what is left before metered spend draws it down. It is a READ of the caller\'s own subject, pinned before the handler runs, so a grant belonging to another tenant is simply absent. Granting credit is not this route and never has been: minting lands on the mint-gated POST /v1/billing/credit, which no browser can reach. Reading an empty balance is an empty array, not an error.
      * @summary List the credit grants on your org\'s balance
@@ -3014,6 +3135,17 @@ export class BillingApi extends BaseAPI {
         return BillingApiFp(this.configuration).getBillingUsageAccounts(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * Answers the one read the account page renders: the subject\'s resolved plan, the plan\'s included monthly allotment beside what was actually granted this period, consumption capped at that grant, the overage past it, and the spendable wallet (balance minus holds) — all for the current UTC month, every figure derived from the same transactions the gateway\'s balance gate reads, so this read can never disagree with the gate that admits the next call. It rides the same pinned chain as the sibling reads: the user parameter is overwritten with the validated caller\'s own billing subject before the handler runs, so it can never name another tenant; user is required, which only a service-to-service caller can omit and be refused 400 for, and plan is optional — omitted, it is resolved from the subject\'s subscription. The rule to get right is that the two sides are DIFFERENT MONEY: the included figures are usage the subscription grants and the wallet is prepaid credit the customer bought, so a reader who sums them invents a balance nobody holds — and before the period\'s first allotment grant runs, monthlyCents shows the plan\'s entitlement while grantedCents is zero, which is the figure consumption actually draws down.
+     * @summary What plan you are on and how much of it is left, beside the wallet
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof BillingApi
+     */
+    public getBillingUsageRollup(options?: RawAxiosRequestConfig) {
+        return BillingApiFp(this.configuration).getBillingUsageRollup(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Answers the receiving bank details for the brand this deployment serves — the account the funds actually land in, hydrated per brand rather than hard-coded — together with the payment reference to put on the transfer.  THE REFERENCE IS THE POINT. It carries your own billing key, and it is how an arriving wire is attributed to your account; a transfer sent without it arrives as an unidentified receipt. That is why this read is gated at all: an unpinned caller would be handed an unattributable reference.  Reading it credits nothing and reserves nothing. A wire is settled by an operator when the bank shows the funds, so the balance moves on receipt, not on this call.
      * @summary Where to wire funds, and the reference that credits them to you

package/src/api/chat-api.ts

@@ -86,6 +86,40 @@ export const ChatApiAxiosParamCreator = function (configuration?: Configuration)
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * Serves one completion to a caller with no account.
+         * @summary Serves one completion to a caller with no account.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postChatPublic: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/v1/chat/public`;
+            // 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 = {} as any;
+            const localVarQueryParameter = {} as any;
+
+            // 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};
@@ -129,6 +163,18 @@ export const ChatApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['ChatApi.postChatCompletions']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * Serves one completion to a caller with no account.
+         * @summary Serves one completion to a caller with no account.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async postChatPublic(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.postChatPublic(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['ChatApi.postChatPublic']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
     }
 };
 
@@ -157,6 +203,15 @@ export const ChatApiFactory = function (configuration?: Configuration, basePath?
         postChatCompletions(options?: RawAxiosRequestConfig): AxiosPromise<void> {
             return localVarFp.postChatCompletions(options).then((request) => request(axios, basePath));
         },
+        /**
+         * Serves one completion to a caller with no account.
+         * @summary Serves one completion to a caller with no account.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        postChatPublic(options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.postChatPublic(options).then((request) => request(axios, basePath));
+        },
     };
 };
 
@@ -188,5 +243,16 @@ export class ChatApi extends BaseAPI {
     public postChatCompletions(options?: RawAxiosRequestConfig) {
         return ChatApiFp(this.configuration).postChatCompletions(options).then((request) => request(this.axios, this.basePath));
     }
+
+    /**
+     * Serves one completion to a caller with no account.
+     * @summary Serves one completion to a caller with no account.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof ChatApi
+     */
+    public postChatPublic(options?: RawAxiosRequestConfig) {
+        return ChatApiFp(this.configuration).postChatPublic(options).then((request) => request(this.axios, this.basePath));
+    }
 }
 

package/src/api/compliance-api.ts

@@ -135,8 +135,8 @@ export const ComplianceApiAxiosParamCreator = function (configuration?: Configur
             };
         },
         /**
-         * AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
-         * @summary AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
+         * AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
+         * @summary AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
          * @param {string} [result] Result filters rows by outcome result: success, deny, or error; empty means all.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -751,8 +751,8 @@ export const ComplianceApiFp = function(configuration?: Configuration) {
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
-         * @summary AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
+         * AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
+         * @summary AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
          * @param {string} [result] Result filters rows by outcome result: success, deny, or error; empty means all.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -975,8 +975,8 @@ export const ComplianceApiFactory = function (configuration?: Configuration, bas
             return localVarFp.getComplianceAccreditationById(requestParameters.id, options).then((request) => request(axios, basePath));
         },
         /**
-         * AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
-         * @summary AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
+         * AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
+         * @summary AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
          * @param {ComplianceApiGetComplianceAuditRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
@@ -1366,8 +1366,8 @@ export class ComplianceApi extends BaseAPI {
     }
 
     /**
-     * AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
-     * @summary AuditRead is the compliance-scoped read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
+     * AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when). The org is PINNED to the caller\'s validated org and the rows are narrowed to compliance.* actions. Fail-closed: no principal is a 403, no configured audit store a 501.
+     * @summary AuditRead is the compliance read of the SHARED tamper-evident audit plane — the SOC 2 posture surface (privileged actions: who started/decided what, when).
      * @param {ComplianceApiGetComplianceAuditRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}

package/src/api/default-api.ts

@@ -1194,6 +1194,36 @@ export const DefaultApiAxiosParamCreator = function (configuration?: Configurati
 
 
     
+            setSearchParams(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
+
+            return {
+                url: toPathString(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+        /**
+         * The same document /v1/openapi.json serves, at the address RFC 8615 reserves for discovery — one handler over one render, so the two cannot describe different APIs.  It exists because a client that has never seen this API probes here first. Prefer /v1/openapi.json when you already know the API: it is canonical, and it is what the document\'s own self-description names.
+         * @summary The API description, at the conventional address
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getWellKnownOpenapiJson: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            const localVarPath = `/.well-known/openapi.json`;
+            // 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: 'GET', ...baseOptions, ...options};
+            const localVarHeaderParameter = {} as any;
+            const localVarQueryParameter = {} as any;
+
+
+    
             setSearchParams(localVarUrlObj, localVarQueryParameter);
             let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
             localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
@@ -2351,6 +2381,18 @@ export const DefaultApiFp = function(configuration?: Configuration) {
             const localVarOperationServerBasePath = operationServerMap['DefaultApi.getWellKnownOauthAuthorizationServer']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
+        /**
+         * The same document /v1/openapi.json serves, at the address RFC 8615 reserves for discovery — one handler over one render, so the two cannot describe different APIs.  It exists because a client that has never seen this API probes here first. Prefer /v1/openapi.json when you already know the API: it is canonical, and it is what the document\'s own self-description names.
+         * @summary The API description, at the conventional address
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getWellKnownOpenapiJson(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getWellKnownOpenapiJson(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = operationServerMap['DefaultApi.getWellKnownOpenapiJson']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
         /**
          * Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.  It advertises only what is actually implemented, so a client that reads it cannot ask for a flow that will fail: the authorization-code flow, PKCE with S256, the supported grants, and the signing algorithms whose public keys the JWKS really publishes.  The issuer is derived from the host you asked on and is the same value the tokens carry, so a client that pins the issuer never sees it change.
          * @summary Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
@@ -2905,6 +2947,15 @@ export const DefaultApiFactory = function (configuration?: Configuration, basePa
         getWellKnownOauthAuthorizationServer(options?: RawAxiosRequestConfig): AxiosPromise<void> {
             return localVarFp.getWellKnownOauthAuthorizationServer(options).then((request) => request(axios, basePath));
         },
+        /**
+         * The same document /v1/openapi.json serves, at the address RFC 8615 reserves for discovery — one handler over one render, so the two cannot describe different APIs.  It exists because a client that has never seen this API probes here first. Prefer /v1/openapi.json when you already know the API: it is canonical, and it is what the document\'s own self-description names.
+         * @summary The API description, at the conventional address
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getWellKnownOpenapiJson(options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.getWellKnownOpenapiJson(options).then((request) => request(axios, basePath));
+        },
         /**
          * Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.  It advertises only what is actually implemented, so a client that reads it cannot ask for a flow that will fail: the authorization-code flow, PKCE with S256, the supported grants, and the signing algorithms whose public keys the JWKS really publishes.  The issuer is derived from the host you asked on and is the same value the tokens carry, so a client that pins the issuer never sees it change.
          * @summary Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.
@@ -3999,6 +4050,17 @@ export class DefaultApi extends BaseAPI {
         return DefaultApiFp(this.configuration).getWellKnownOauthAuthorizationServer(options).then((request) => request(this.axios, this.basePath));
     }
 
+    /**
+     * The same document /v1/openapi.json serves, at the address RFC 8615 reserves for discovery — one handler over one render, so the two cannot describe different APIs.  It exists because a client that has never seen this API probes here first. Prefer /v1/openapi.json when you already know the API: it is canonical, and it is what the document\'s own self-description names.
+     * @summary The API description, at the conventional address
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof DefaultApi
+     */
+    public getWellKnownOpenapiJson(options?: RawAxiosRequestConfig) {
+        return DefaultApiFp(this.configuration).getWellKnownOpenapiJson(options).then((request) => request(this.axios, this.basePath));
+    }
+
     /**
      * Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.  It advertises only what is actually implemented, so a client that reads it cannot ask for a flow that will fail: the authorization-code flow, PKCE with S256, the supported grants, and the signing algorithms whose public keys the JWKS really publishes.  The issuer is derived from the host you asked on and is the same value the tokens carry, so a client that pins the issuer never sees it change.
      * @summary Returns the OpenID Connect discovery document — the one URL you point a standards-compliant client at so it can find every other endpoint on its own, instead of you configuring them by hand.

package/src/api/documents-api.ts

@@ -64,11 +64,15 @@ export const DocumentsApiAxiosParamCreator = function (configuration?: Configura
         /**
          * Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
          * @summary Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
+         * @param {string} fileId 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getDocumentsByFileIdContext: async (options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
-            const localVarPath = `/v1/documents/{file_id}/context`;
+        getDocumentsByFileIdContext: async (fileId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
+            // verify required parameter 'fileId' is not null or undefined
+            assertParamExists('getDocumentsByFileIdContext', 'fileId', fileId)
+            const localVarPath = `/v1/documents/{file_id}/context`
+                .replace(`{${"file_id"}}`, encodeURIComponent(String(fileId)));
             // use dummy base URL string because the URL constructor only accepts absolute URLs.
             const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
             let baseOptions;
@@ -120,11 +124,12 @@ export const DocumentsApiFp = function(configuration?: Configuration) {
         /**
          * Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
          * @summary Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
+         * @param {string} fileId 
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        async getDocumentsByFileIdContext(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getDocumentsByFileIdContext(options);
+        async getDocumentsByFileIdContext(fileId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getDocumentsByFileIdContext(fileId, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = operationServerMap['DocumentsApi.getDocumentsByFileIdContext']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -151,15 +156,30 @@ export const DocumentsApiFactory = function (configuration?: Configuration, base
         /**
          * Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
          * @summary Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
+         * @param {DocumentsApiGetDocumentsByFileIdContextRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
          * @throws {RequiredError}
          */
-        getDocumentsByFileIdContext(options?: RawAxiosRequestConfig): AxiosPromise<void> {
-            return localVarFp.getDocumentsByFileIdContext(options).then((request) => request(axios, basePath));
+        getDocumentsByFileIdContext(requestParameters: DocumentsApiGetDocumentsByFileIdContextRequest, options?: RawAxiosRequestConfig): AxiosPromise<void> {
+            return localVarFp.getDocumentsByFileIdContext(requestParameters.fileId, options).then((request) => request(axios, basePath));
         },
     };
 };
 
+/**
+ * Request parameters for getDocumentsByFileIdContext operation in DocumentsApi.
+ * @export
+ * @interface DocumentsApiGetDocumentsByFileIdContextRequest
+ */
+export interface DocumentsApiGetDocumentsByFileIdContextRequest {
+    /**
+     * 
+     * @type {string}
+     * @memberof DocumentsApiGetDocumentsByFileIdContext
+     */
+    readonly fileId: string
+}
+
 /**
  * DocumentsApi - object-oriented interface
  * @export
@@ -181,12 +201,13 @@ export class DocumentsApi extends BaseAPI {
     /**
      * Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
      * @summary Handles GET /v1/documents/:file_id/context — every chunk of a file, as LangChain Documents (used when RAG_USE_FULL_CONTEXT is on).
+     * @param {DocumentsApiGetDocumentsByFileIdContextRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
      * @throws {RequiredError}
      * @memberof DocumentsApi
      */
-    public getDocumentsByFileIdContext(options?: RawAxiosRequestConfig) {
-        return DocumentsApiFp(this.configuration).getDocumentsByFileIdContext(options).then((request) => request(this.axios, this.basePath));
+    public getDocumentsByFileIdContext(requestParameters: DocumentsApiGetDocumentsByFileIdContextRequest, options?: RawAxiosRequestConfig) {
+        return DocumentsApiFp(this.configuration).getDocumentsByFileIdContext(requestParameters.fileId, options).then((request) => request(this.axios, this.basePath));
     }
 }