mindee 4.35.0 → 4.36.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## v4.36.0 - 2025-12-19
+### Changes
+* :sparkles: add support for dataschema param
+
+
 ## v4.35.0 - 2025-12-16
 ### Changes
 * :sparkles: add multi-receipt custom file saving formats

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mindee",
-    "version": "4.35.0",
+    "version": "4.36.0",
     "description": "Mindee Client Library for Node.js",
     "main": "src/index.js",
     "bin": "bin/mindee.js",

package/src/clientV2.d.ts

@@ -1,6 +1,7 @@
-import { InputSource } from "./input";
+import { DataSchema, InputSource } from "./input";
 import { InferenceResponse, JobResponse } from "./parsing/v2";
 import { MindeeApiV2 } from "./http/mindeeApiV2";
+import { StringDict } from "./parsing/common";
 /**
  * Parameters for the internal polling loop in {@link ClientV2.enqueueAndGetInference | enqueueAndGetInference()} .
  *
@@ -88,6 +89,11 @@ export interface InferenceParameters {
     /** By default, the file is closed once the upload is finished.
      * Set to `false` to keep it open. */
     closeFile?: boolean;
+    /**
+     * Dynamic changes to the data schema of the model for this inference.
+     * Not recommended, for specific use only.
+     */
+    dataSchema?: DataSchema | StringDict | string;
 }
 /**
  * Options for the V2 Mindee Client.
@@ -121,6 +127,11 @@ export declare class ClientV2 {
      * @param {ClientOptions} options options for the initialization of a client.
      */
     constructor({ apiKey, throwOnError, debug }?: ClientOptions);
+    /**
+     * Checks the Data Schema.
+     * @param params Input Inference parameters.
+     */
+    validateDataSchema(params: InferenceParameters): void;
     /**
      * Send the document to an asynchronous endpoint and return its ID in the queue.
      * @param inputSource file or URL to parse.

package/src/clientV2.js

@@ -7,6 +7,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _ClientV2_instances, _ClientV2_setAsyncParams;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClientV2 = void 0;
+const input_1 = require("./input");
 const handler_1 = require("./errors/handler");
 const logger_1 = require("./logger");
 const promises_1 = require("node:timers/promises");
@@ -35,6 +36,17 @@ class ClientV2 {
                 : logger_1.LOG_LEVELS["warn"];
         logger_1.logger.debug("ClientV2 initialized");
     }
+    /**
+     * Checks the Data Schema.
+     * @param params Input Inference parameters.
+     */
+    validateDataSchema(params) {
+        if (params.dataSchema !== undefined && params.dataSchema !== null) {
+            if (!(params.dataSchema instanceof input_1.DataSchema)) {
+                params.dataSchema = new input_1.DataSchema(params.dataSchema);
+            }
+        }
+    }
     /**
      * Send the document to an asynchronous endpoint and return its ID in the queue.
      * @param inputSource file or URL to parse.
@@ -46,6 +58,7 @@ class ClientV2 {
         if (inputSource === undefined) {
             throw new Error("The 'enqueue' function requires an input document.");
         }
+        this.validateDataSchema(params);
         await inputSource.init();
         return await this.mindeeApi.reqPostInferenceEnqueue(inputSource, params);
     }

package/src/http/mindeeApiV2.js

@@ -102,6 +102,9 @@ _MindeeApiV2_instances = new WeakSet(), _MindeeApiV2_processResponse = function
     if (params.textContext !== undefined && params.textContext !== null) {
         form.append("text_context", params.textContext);
     }
+    if (params.dataSchema !== undefined && params.dataSchema !== null) {
+        form.append("data_schema", params.dataSchema.toString());
+    }
     if (params.webhookIds && params.webhookIds.length > 0) {
         form.append("webhook_ids", params.webhookIds.join(","));
     }

package/src/input/dataSchema.d.ts

@@ -0,0 +1,73 @@
+import { StringDict } from "../parsing/common";
+export declare class DataSchemaField {
+    /**
+     * Display name for the field, also impacts inference results.
+     */
+    title: string;
+    /**
+     * Name of the field in the data schema.
+     */
+    name: string;
+    /**
+     * Whether this field can contain multiple values.
+     */
+    isArray: boolean;
+    /**
+     * Data type of the field.
+     */
+    type: string;
+    /**
+     * Allowed values when type is `classification`. Leave empty for other types.
+     */
+    classificationValues?: Array<string>;
+    /**
+     * Whether to remove duplicate values in the array.
+     * Only applicable if `is_array` is True.
+     */
+    uniqueValues?: boolean;
+    /**
+     * Detailed description of what this field represents.
+     */
+    description?: string;
+    /**
+     * Optional extraction guidelines.
+     */
+    guidelines?: string;
+    /**
+     * Subfields when type is `nested_object`. Leave empty for other types.
+     */
+    nestedFields?: StringDict;
+    constructor(fields: StringDict);
+    toJSON(): Record<string, unknown>;
+    toString(): string;
+}
+/**
+ * The structure to completely replace the data schema of the model.
+ */
+export declare class DataSchemaReplace {
+    /**
+     * List of fields in the Data Schema.
+     */
+    fields: Array<DataSchemaField>;
+    constructor(dataSchemaReplace: StringDict);
+    toJSON(): {
+        fields: Record<string, unknown>[];
+    };
+    toString(): string;
+}
+/**
+ * Modify the Data Schema.
+ */
+export declare class DataSchema {
+    /**
+     * If set, completely replaces the data schema of the model.
+     */
+    replace?: DataSchemaReplace;
+    constructor(dataSchema: StringDict | string);
+    toJSON(): {
+        replace: {
+            fields: Record<string, unknown>[];
+        } | undefined;
+    };
+    toString(): string;
+}

package/src/input/dataSchema.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSchema = exports.DataSchemaReplace = exports.DataSchemaField = void 0;
+const errors_1 = require("../errors");
+class DataSchemaField {
+    constructor(fields) {
+        this.name = fields["name"];
+        this.title = fields["title"];
+        this.isArray = fields["is_array"];
+        this.type = fields["type"];
+        this.classificationValues = fields["classification_values"];
+        this.uniqueValues = fields["unique_values"];
+        this.description = fields["description"];
+        this.guidelines = fields["guidelines"];
+        this.nestedFields = fields["nested_fields"];
+    }
+    toJSON() {
+        const out = {
+            name: this.name,
+            title: this.title,
+            // eslint-disable-next-line @typescript-eslint/naming-convention,camelcase
+            is_array: this.isArray,
+            type: this.type,
+        };
+        // eslint-disable-next-line camelcase
+        if (this.classificationValues !== undefined)
+            out.classification_values = this.classificationValues;
+        // eslint-disable-next-line camelcase
+        if (this.uniqueValues !== undefined)
+            out.unique_values = this.uniqueValues;
+        if (this.description !== undefined)
+            out.description = this.description;
+        if (this.guidelines !== undefined)
+            out.guidelines = this.guidelines;
+        // eslint-disable-next-line camelcase
+        if (this.nestedFields !== undefined)
+            out.nested_fields = this.nestedFields;
+        return out;
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+exports.DataSchemaField = DataSchemaField;
+/**
+ * The structure to completely replace the data schema of the model.
+ */
+class DataSchemaReplace {
+    constructor(dataSchemaReplace) {
+        if (!dataSchemaReplace || !dataSchemaReplace.fields) {
+            throw new errors_1.MindeeError("Invalid Data Schema provided.");
+        }
+        if (dataSchemaReplace["fields"].length === 0) {
+            throw new TypeError("Data Schema replacement fields cannot be empty.");
+        }
+        this.fields = dataSchemaReplace["fields"].map((field) => (new DataSchemaField(field)));
+    }
+    toJSON() {
+        return { fields: this.fields.map(e => e.toJSON()) };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+exports.DataSchemaReplace = DataSchemaReplace;
+/**
+ * Modify the Data Schema.
+ */
+class DataSchema {
+    constructor(dataSchema) {
+        if (typeof dataSchema === "string") {
+            this.replace = new DataSchemaReplace(JSON.parse(dataSchema)["replace"]);
+        }
+        else if (dataSchema["replace"] instanceof DataSchemaReplace) {
+            this.replace = dataSchema["replace"];
+        }
+        else {
+            this.replace = new DataSchemaReplace(dataSchema["replace"]);
+        }
+    }
+    toJSON() {
+        return { replace: this.replace?.toJSON() };
+    }
+    toString() {
+        return JSON.stringify(this.toJSON());
+    }
+}
+exports.DataSchema = DataSchema;

package/src/input/index.d.ts

@@ -1,3 +1,4 @@
-export { PageOptions, PageOptionsOperation } from "./pageOptions";
+export { DataSchema, DataSchemaField, DataSchemaReplace } from "./dataSchema";
 export * from "./sources";
 export { LocalResponse } from "./localResponse";
+export { PageOptions, PageOptionsOperation } from "./pageOptions";

package/src/input/index.js

@@ -14,9 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalResponse = exports.PageOptionsOperation = void 0;
-var pageOptions_1 = require("./pageOptions");
-Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return pageOptions_1.PageOptionsOperation; } });
+exports.PageOptionsOperation = exports.LocalResponse = exports.DataSchemaReplace = exports.DataSchemaField = exports.DataSchema = void 0;
+var dataSchema_1 = require("./dataSchema");
+Object.defineProperty(exports, "DataSchema", { enumerable: true, get: function () { return dataSchema_1.DataSchema; } });
+Object.defineProperty(exports, "DataSchemaField", { enumerable: true, get: function () { return dataSchema_1.DataSchemaField; } });
+Object.defineProperty(exports, "DataSchemaReplace", { enumerable: true, get: function () { return dataSchema_1.DataSchemaReplace; } });
 __exportStar(require("./sources"), exports);
 var localResponse_1 = require("./localResponse");
 Object.defineProperty(exports, "LocalResponse", { enumerable: true, get: function () { return localResponse_1.LocalResponse; } });
+var pageOptions_1 = require("./pageOptions");
+Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return pageOptions_1.PageOptionsOperation; } });

package/src/parsing/v2/dataSchemaActiveOption.d.ts

@@ -0,0 +1,12 @@
+import { StringDict } from "../common";
+/**
+ * Data schema options activated during the inference.
+ */
+export declare class DataSchemaActiveOption {
+    /**
+     * Whether to replace the data schema.
+     */
+    replace: boolean;
+    constructor(serverResponse: StringDict);
+    toString(): string;
+}

package/src/parsing/v2/dataSchemaActiveOption.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSchemaActiveOption = void 0;
+/**
+ * Data schema options activated during the inference.
+ */
+class DataSchemaActiveOption {
+    constructor(serverResponse) {
+        this.replace = serverResponse["replace"];
+    }
+    toString() {
+        return `Data Schema\n-----------\n:Replace: ${this.replace ? "True" : "False"}`;
+    }
+}
+exports.DataSchemaActiveOption = DataSchemaActiveOption;

package/src/parsing/v2/inferenceActiveOptions.d.ts

@@ -1,4 +1,5 @@
 import { StringDict } from "../common";
+import { DataSchemaActiveOption } from "./dataSchemaActiveOption";
 export declare class InferenceActiveOptions {
     /**
      * Whether the RAG feature was activated.
@@ -20,6 +21,10 @@ export declare class InferenceActiveOptions {
      * Whether the text context feature was activated.
      */
     textContext: boolean;
+    /**
+     * Data schema options provided for the inference.
+     */
+    dataSchema: DataSchemaActiveOption;
     constructor(serverResponse: StringDict);
     toString(): string;
 }

package/src/parsing/v2/inferenceActiveOptions.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InferenceActiveOptions = void 0;
+const dataSchemaActiveOption_1 = require("./dataSchemaActiveOption");
 class InferenceActiveOptions {
     constructor(serverResponse) {
         this.rag = serverResponse["rag"];
@@ -8,6 +9,7 @@ class InferenceActiveOptions {
         this.polygon = serverResponse["polygon"];
         this.confidence = serverResponse["confidence"];
         this.textContext = serverResponse["text_context"];
+        this.dataSchema = new dataSchemaActiveOption_1.DataSchemaActiveOption(serverResponse["data_schema"]);
     }
     toString() {
         return "Active Options\n" +
@@ -15,7 +17,9 @@ class InferenceActiveOptions {
             `:Raw Text: ${this.rawText ? "True" : "False"}\n` +
             `:Polygon: ${this.polygon ? "True" : "False"}\n` +
             `:Confidence: ${this.confidence ? "True" : "False"}\n` +
-            `:RAG: ${this.rag ? "True" : "False"}\n`;
+            `:RAG: ${this.rag ? "True" : "False"}\n` +
+            `:Text Context: ${this.textContext ? "True" : "False"}\n\n` +
+            `${this.dataSchema}\n`;
     }
 }
 exports.InferenceActiveOptions = InferenceActiveOptions;