hanzoai 2.2.10 → 8.5.89

package/dist/api/documents-api.d.ts

@@ -28,10 +28,11 @@ export declare const DocumentsApiAxiosParamCreator: (configuration?: Configurati
     /**
      * 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: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+    getDocumentsByFileIdContext: (fileId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
 };
 /**
  * DocumentsApi - functional programming interface
@@ -48,10 +49,11 @@ export declare const DocumentsApiFp: (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}
      */
-    getDocumentsByFileIdContext(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
+    getDocumentsByFileIdContext(fileId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
 };
 /**
  * DocumentsApi - factory interface
@@ -68,11 +70,25 @@ export declare const DocumentsApiFactory: (configuration?: Configuration, basePa
     /**
      * 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>;
+    getDocumentsByFileIdContext(requestParameters: DocumentsApiGetDocumentsByFileIdContextRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
 };
+/**
+ * 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
@@ -91,9 +107,10 @@ export declare 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
      */
-    getDocumentsByFileIdContext(options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<void, any, {}>>;
+    getDocumentsByFileIdContext(requestParameters: DocumentsApiGetDocumentsByFileIdContextRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<void, any, {}>>;
 }

package/dist/api/documents-api.js

@@ -60,11 +60,15 @@ const DocumentsApiAxiosParamCreator = function (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}
          */
-        getDocumentsByFileIdContext: async (options = {}) => {
-            const localVarPath = `/v1/documents/{file_id}/context`;
+        getDocumentsByFileIdContext: async (fileId, options = {}) => {
+            // verify required parameter 'fileId' is not null or undefined
+            (0, common_1.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, common_1.DUMMY_BASE_URL);
             let baseOptions;
@@ -110,11 +114,12 @@ const DocumentsApiFp = function (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) {
-            const localVarAxiosArgs = await localVarAxiosParamCreator.getDocumentsByFileIdContext(options);
+        async getDocumentsByFileIdContext(fileId, options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getDocumentsByFileIdContext(fileId, options);
             const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
             const localVarOperationServerBasePath = base_1.operationServerMap['DocumentsApi.getDocumentsByFileIdContext']?.[localVarOperationServerIndex]?.url;
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -141,11 +146,12 @@ const DocumentsApiFactory = function (configuration, basePath, axios) {
         /**
          * 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) {
-            return localVarFp.getDocumentsByFileIdContext(options).then((request) => request(axios, basePath));
+        getDocumentsByFileIdContext(requestParameters, options) {
+            return localVarFp.getDocumentsByFileIdContext(requestParameters.fileId, options).then((request) => request(axios, basePath));
         },
     };
 };
@@ -170,12 +176,13 @@ class DocumentsApi extends base_1.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
      */
-    getDocumentsByFileIdContext(options) {
-        return (0, exports.DocumentsApiFp)(this.configuration).getDocumentsByFileIdContext(options).then((request) => request(this.axios, this.basePath));
+    getDocumentsByFileIdContext(requestParameters, options) {
+        return (0, exports.DocumentsApiFp)(this.configuration).getDocumentsByFileIdContext(requestParameters.fileId, options).then((request) => request(this.axios, this.basePath));
     }
 }
 exports.DocumentsApi = DocumentsApi;

package/dist/api/edge-api.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Hanzo Cloud API
+ * Composed from each subsystem\'s own projection of its router, in the fleet\'s mount order — every operation below is a route the subsystem that publishes it registered. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * 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 { Configuration } from '../configuration';
+import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from 'axios';
+import globalAxios from 'axios';
+import { type RequestArgs, BaseAPI } from '../base';
+import type { EdgeState } from '../models';
+/**
+ * EdgeApi - axios parameter creator
+ * @export
+ */
+export declare const EdgeApiAxiosParamCreator: (configuration?: Configuration) => {
+    /**
+     * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+     * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getEdge: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
+};
+/**
+ * EdgeApi - functional programming interface
+ * @export
+ */
+export declare const EdgeApiFp: (configuration?: Configuration) => {
+    /**
+     * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+     * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getEdge(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<EdgeState>>;
+};
+/**
+ * EdgeApi - factory interface
+ * @export
+ */
+export declare const EdgeApiFactory: (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) => {
+    /**
+     * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+     * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     */
+    getEdge(options?: RawAxiosRequestConfig): AxiosPromise<EdgeState>;
+};
+/**
+ * EdgeApi - object-oriented interface
+ * @export
+ * @class EdgeApi
+ * @extends {BaseAPI}
+ */
+export declare class EdgeApi extends BaseAPI {
+    /**
+     * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+     * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof EdgeApi
+     */
+    getEdge(options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<EdgeState, any, {}>>;
+}

package/dist/api/edge-api.js

@@ -0,0 +1,122 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Hanzo Cloud API
+ * Composed from each subsystem\'s own projection of its router, in the fleet\'s mount order — every operation below is a route the subsystem that publishes it registered. Tagged by product: the first path segment after /v1/.
+ *
+ * The version of the OpenAPI document: v1
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EdgeApi = exports.EdgeApiFactory = exports.EdgeApiFp = exports.EdgeApiAxiosParamCreator = void 0;
+const axios_1 = __importDefault(require("axios"));
+// Some imports not used depending on template conditions
+// @ts-ignore
+const common_1 = require("../common");
+// @ts-ignore
+const base_1 = require("../base");
+/**
+ * EdgeApi - axios parameter creator
+ * @export
+ */
+const EdgeApiAxiosParamCreator = function (configuration) {
+    return {
+        /**
+         * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+         * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getEdge: async (options = {}) => {
+            const localVarPath = `/v1/edge`;
+            // use dummy base URL string because the URL constructor only accepts absolute URLs.
+            const localVarUrlObj = new URL(localVarPath, common_1.DUMMY_BASE_URL);
+            let baseOptions;
+            if (configuration) {
+                baseOptions = configuration.baseOptions;
+            }
+            const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options };
+            const localVarHeaderParameter = {};
+            const localVarQueryParameter = {};
+            // authentication bearer required
+            // http bearer authentication required
+            await (0, common_1.setBearerAuthToObject)(localVarHeaderParameter, configuration);
+            (0, common_1.setSearchParams)(localVarUrlObj, localVarQueryParameter);
+            let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
+            localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
+            return {
+                url: (0, common_1.toPathString)(localVarUrlObj),
+                options: localVarRequestOptions,
+            };
+        },
+    };
+};
+exports.EdgeApiAxiosParamCreator = EdgeApiAxiosParamCreator;
+/**
+ * EdgeApi - functional programming interface
+ * @export
+ */
+const EdgeApiFp = function (configuration) {
+    const localVarAxiosParamCreator = (0, exports.EdgeApiAxiosParamCreator)(configuration);
+    return {
+        /**
+         * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+         * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        async getEdge(options) {
+            const localVarAxiosArgs = await localVarAxiosParamCreator.getEdge(options);
+            const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
+            const localVarOperationServerBasePath = base_1.operationServerMap['EdgeApi.getEdge']?.[localVarOperationServerIndex]?.url;
+            return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
+        },
+    };
+};
+exports.EdgeApiFp = EdgeApiFp;
+/**
+ * EdgeApi - factory interface
+ * @export
+ */
+const EdgeApiFactory = function (configuration, basePath, axios) {
+    const localVarFp = (0, exports.EdgeApiFp)(configuration);
+    return {
+        /**
+         * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+         * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+         * @param {*} [options] Override http request option.
+         * @throws {RequiredError}
+         */
+        getEdge(options) {
+            return localVarFp.getEdge(options).then((request) => request(axios, basePath));
+        },
+    };
+};
+exports.EdgeApiFactory = EdgeApiFactory;
+/**
+ * EdgeApi - object-oriented interface
+ * @export
+ * @class EdgeApi
+ * @extends {BaseAPI}
+ */
+class EdgeApi extends base_1.BaseAPI {
+    /**
+     * health reports whether a publish reaches readers, rather than whether it was accepted. Those are different questions and only the second one was ever visible.  It asks the edge and nothing else. There is no live call to the provider here: Configured is a local fact, it is the fact that was missing, and a health check that spends a third-party API call is one an operator learns not to run.
+     * @summary health reports whether a publish reaches readers, rather than whether it was accepted.
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof EdgeApi
+     */
+    getEdge(options) {
+        return (0, exports.EdgeApiFp)(this.configuration).getEdge(options).then((request) => request(this.axios, this.basePath));
+    }
+}
+exports.EdgeApi = EdgeApi;

package/dist/api/esign-api.d.ts

@@ -57,7 +57,7 @@ export declare const EsignApiAxiosParamCreator: (configuration?: Configuration)
      */
     getEsignHealth: (options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
      * @summary Open a document you were asked to sign, using your signing link
      * @param {string} org
      * @param {string} token
@@ -97,7 +97,7 @@ export declare const EsignApiAxiosParamCreator: (configuration?: Configuration)
      */
     postEsignDocumentsByIdSend: (id: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
      * @summary Finish signing — and seal the document if you were the last
      * @param {string} org
      * @param {string} token
@@ -116,7 +116,7 @@ export declare const EsignApiAxiosParamCreator: (configuration?: Configuration)
      */
     postEsignOByOrgSignByTokenFieldsByFieldid: (org: string, token: string, fieldId: string, options?: RawAxiosRequestConfig) => Promise<RequestArgs>;
     /**
-     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
      * @summary Decline to sign, with an optional reason
      * @param {string} org
      * @param {string} token
@@ -169,7 +169,7 @@ export declare const EsignApiFp: (configuration?: Configuration) => {
      */
     getEsignHealth(options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
     /**
-     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
      * @summary Open a document you were asked to sign, using your signing link
      * @param {string} org
      * @param {string} token
@@ -209,7 +209,7 @@ export declare const EsignApiFp: (configuration?: Configuration) => {
      */
     postEsignDocumentsByIdSend(id: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
     /**
-     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
      * @summary Finish signing — and seal the document if you were the last
      * @param {string} org
      * @param {string} token
@@ -228,7 +228,7 @@ export declare const EsignApiFp: (configuration?: Configuration) => {
      */
     postEsignOByOrgSignByTokenFieldsByFieldid(org: string, token: string, fieldId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>>;
     /**
-     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
      * @summary Decline to sign, with an optional reason
      * @param {string} org
      * @param {string} token
@@ -281,7 +281,7 @@ export declare const EsignApiFactory: (configuration?: Configuration, basePath?:
      */
     getEsignHealth(options?: RawAxiosRequestConfig): AxiosPromise<void>;
     /**
-     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
      * @summary Open a document you were asked to sign, using your signing link
      * @param {EsignApiGetEsignOByOrgSignByTokenRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -320,7 +320,7 @@ export declare const EsignApiFactory: (configuration?: Configuration, basePath?:
      */
     postEsignDocumentsByIdSend(requestParameters: EsignApiPostEsignDocumentsByIdSendRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
     /**
-     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
      * @summary Finish signing — and seal the document if you were the last
      * @param {EsignApiPostEsignOByOrgSignByTokenCompleteRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -336,7 +336,7 @@ export declare const EsignApiFactory: (configuration?: Configuration, basePath?:
      */
     postEsignOByOrgSignByTokenFieldsByFieldid(requestParameters: EsignApiPostEsignOByOrgSignByTokenFieldsByFieldidRequest, options?: RawAxiosRequestConfig): AxiosPromise<void>;
     /**
-     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
      * @summary Decline to sign, with an optional reason
      * @param {EsignApiPostEsignOByOrgSignByTokenRejectRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -555,7 +555,7 @@ export declare class EsignApi extends BaseAPI {
      */
     getEsignHealth(options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<void, any, {}>>;
     /**
-     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
      * @summary Open a document you were asked to sign, using your signing link
      * @param {EsignApiGetEsignOByOrgSignByTokenRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -599,7 +599,7 @@ export declare class EsignApi extends BaseAPI {
      */
     postEsignDocumentsByIdSend(requestParameters: EsignApiPostEsignDocumentsByIdSendRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<void, any, {}>>;
     /**
-     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
      * @summary Finish signing — and seal the document if you were the last
      * @param {EsignApiPostEsignOByOrgSignByTokenCompleteRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -617,7 +617,7 @@ export declare class EsignApi extends BaseAPI {
      */
     postEsignOByOrgSignByTokenFieldsByFieldid(requestParameters: EsignApiPostEsignOByOrgSignByTokenFieldsByFieldidRequest, options?: RawAxiosRequestConfig): Promise<globalAxios.AxiosResponse<void, any, {}>>;
     /**
-     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
      * @summary Decline to sign, with an optional reason
      * @param {EsignApiPostEsignOByOrgSignByTokenRejectRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.

package/dist/api/esign-api.js

@@ -182,7 +182,7 @@ const EsignApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
          * @summary Open a document you were asked to sign, using your signing link
          * @param {string} org
          * @param {string} token
@@ -342,7 +342,7 @@ const EsignApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
          * @summary Finish signing — and seal the document if you were the last
          * @param {string} org
          * @param {string} token
@@ -418,7 +418,7 @@ const EsignApiAxiosParamCreator = function (configuration) {
             };
         },
         /**
-         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
          * @summary Decline to sign, with an optional reason
          * @param {string} org
          * @param {string} token
@@ -527,7 +527,7 @@ const EsignApiFp = function (configuration) {
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
          * @summary Open a document you were asked to sign, using your signing link
          * @param {string} org
          * @param {string} token
@@ -592,7 +592,7 @@ const EsignApiFp = function (configuration) {
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
          * @summary Finish signing — and seal the document if you were the last
          * @param {string} org
          * @param {string} token
@@ -621,7 +621,7 @@ const EsignApiFp = function (configuration) {
             return (axios, basePath) => (0, common_1.createRequestFunction)(localVarAxiosArgs, axios_1.default, base_1.BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
         },
         /**
-         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
          * @summary Decline to sign, with an optional reason
          * @param {string} org
          * @param {string} token
@@ -693,7 +693,7 @@ const EsignApiFactory = function (configuration, basePath, axios) {
             return localVarFp.getEsignHealth(options).then((request) => request(axios, basePath));
         },
         /**
-         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+         * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
          * @summary Open a document you were asked to sign, using your signing link
          * @param {EsignApiGetEsignOByOrgSignByTokenRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
@@ -742,7 +742,7 @@ const EsignApiFactory = function (configuration, basePath, axios) {
             return localVarFp.postEsignDocumentsByIdSend(requestParameters.id, options).then((request) => request(axios, basePath));
         },
         /**
-         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+         * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
          * @summary Finish signing — and seal the document if you were the last
          * @param {EsignApiPostEsignOByOrgSignByTokenCompleteRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
@@ -762,7 +762,7 @@ const EsignApiFactory = function (configuration, basePath, axios) {
             return localVarFp.postEsignOByOrgSignByTokenFieldsByFieldid(requestParameters.org, requestParameters.token, requestParameters.fieldId, options).then((request) => request(axios, basePath));
         },
         /**
-         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+         * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
          * @summary Decline to sign, with an optional reason
          * @param {EsignApiPostEsignOByOrgSignByTokenRejectRequest} requestParameters Request parameters.
          * @param {*} [options] Override http request option.
@@ -835,7 +835,7 @@ class EsignApi extends base_1.BaseAPI {
         return (0, exports.EsignApiFp)(this.configuration).getEsignHealth(options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The `:org` segment selects which tenant\'s store is opened, and the token is then looked up inside it — so a token presented under the wrong org simply does not resolve. An unknown or wrong-org token is a 401, never a hint that some other document exists.
+     * Answers the document, the recipient it identifies, the fields THAT recipient must fill, and the PDF to display. The first open also marks the recipient as having opened it and records that on the audit trail, so this read has a side effect by design.  This is the signer\'s door and it takes NO account: the signing token is the entire credential, and it names the recipient, so a signer sees only their own fields and never the other recipients\' tokens. The token resolves to its owning tenant FIRST, before any per-tenant store is opened, and the `:org` segment is only checked against that answer. An unknown or wrong-org token is one and the same 404, never a hint that some other document exists.
      * @summary Open a document you were asked to sign, using your signing link
      * @param {EsignApiGetEsignOByOrgSignByTokenRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -889,7 +889,7 @@ class EsignApi extends base_1.BaseAPI {
         return (0, exports.EsignApiFp)(this.configuration).postEsignDocumentsByIdSend(requestParameters.id, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 401. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
+     * Marks this recipient as done and answers whether the DOCUMENT sealed with it. When every signing recipient has completed, sealing happens right here in the same call: the collected values are rendered onto the PDF, a real x509 PKCS#7 signature is applied, the sealed bytes are stored beside the untouched original, and the document moves to `COMPLETED`. Until then the answer is the recipient\'s own completion with the document still pending.  It refuses to complete a half-filled signature: a recipient with any unfilled field is a 400 naming how many remain. A document not out for signature is a 409, as is a recipient who has already completed, and under SEQUENTIAL order a signer out of turn is a 403. The token is the whole credential — no account, and a token that does not resolve under `:org` is a 404. Sealing and completion are one transaction, so a failure anywhere leaves the document exactly as it was.
      * @summary Finish signing — and seal the document if you were the last
      * @param {EsignApiPostEsignOByOrgSignByTokenCompleteRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.
@@ -911,7 +911,7 @@ class EsignApi extends base_1.BaseAPI {
         return (0, exports.EsignApiFp)(this.configuration).postEsignOByOrgSignByTokenFieldsByFieldid(requestParameters.org, requestParameters.token, requestParameters.fieldId, options).then((request) => request(this.axios, this.basePath));
     }
     /**
-     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 401.
+     * Records this recipient\'s refusal and moves the WHOLE DOCUMENT to `REJECTED` — one declining signer ends it for everyone, and there is no route back: the document cannot then be signed or completed. An optional `reason` is stored and written onto the audit trail with the rejection, which is what the sender sees.  A document not out for signature is a 409, and so is a recipient who has already signed or already rejected — a refusal cannot be taken back or repeated. The token is the whole credential; one that does not resolve under `:org` is a 404.
      * @summary Decline to sign, with an optional reason
      * @param {EsignApiPostEsignOByOrgSignByTokenRejectRequest} requestParameters Request parameters.
      * @param {*} [options] Override http request option.