mindee 4.34.0 → 4.36.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # 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
+### Fixes
+* :bug: fix image extractor dropping quality of extracted PDFs
+
+
 ## v4.34.0 - 2025-12-02
 ### Changes
 * :sparkles: add support for text context

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mindee",
-    "version": "4.34.0",
+    "version": "4.36.0",
     "description": "Mindee Client Library for Node.js",
     "main": "src/index.js",
     "bin": "bin/mindee.js",
@@ -24,7 +24,7 @@
         "CHANGELOG.md"
     ],
     "engines": {
-        "node": ">= 16"
+        "node": ">= 18"
     },
     "repository": {
         "type": "git",

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/imageOperations/common/extractedImage.d.ts

@@ -12,6 +12,13 @@ export declare class ExtractedImage {
      *
      * @param outputPath Path to save the file to.
      */
+    saveToFileAsync(outputPath: string): Promise<void>;
+    /**
+     * Attempts to saves the document to a file synchronously.
+     * Throws an error if the file extension is not supported or if the file could not be saved to disk for some reason.
+     *
+     * @param outputPath Path to save the file to.
+     */
     saveToFile(outputPath: string): void;
     /**
      * Return the file as a Mindee-compatible BufferInput source.

package/src/imageOperations/common/extractedImage.js

@@ -10,6 +10,9 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const logger_1 = require("../../logger");
 const input_1 = require("../../input");
+const localInputSource_1 = require("../../input/sources/localInputSource");
+const node_poppler_1 = require("node-poppler");
+const promises_1 = require("fs/promises");
 /**
  * Generic class for image extraction
  */
@@ -23,9 +26,33 @@ class ExtractedImage {
      *
      * @param outputPath Path to save the file to.
      */
-    saveToFile(outputPath) {
+    async saveToFileAsync(outputPath) {
+        const fileExt = node_path_1.default.extname(outputPath).toLowerCase();
+        if (!localInputSource_1.MIMETYPES.has(fileExt)) {
+            throw new errors_1.MindeeError(`Unsupported file extension: ${fileExt}`);
+        }
         try {
-            (0, node_fs_1.writeFileSync)(node_path_1.default.resolve(outputPath), this.buffer);
+            let outputBuffer = this.buffer;
+            if (fileExt !== ".pdf") {
+                const poppler = new node_poppler_1.Poppler();
+                const options = {
+                    firstPageToConvert: 1,
+                    lastPageToConvert: 1,
+                    singleFile: true,
+                };
+                if (fileExt === ".png") {
+                    options.pngFile = true;
+                }
+                else if (fileExt === ".jpg" || fileExt === ".jpeg") {
+                    options.jpegFile = true;
+                }
+                else if (fileExt === ".tiff" || fileExt === ".tif") {
+                    options.tiffFile = true;
+                }
+                const result = await poppler.pdfToCairo(this.buffer, undefined, options);
+                outputBuffer = node_buffer_1.Buffer.from(result, "latin1");
+            }
+            await (0, promises_1.writeFile)(node_path_1.default.resolve(outputPath), outputBuffer);
             logger_1.logger.info(`File saved successfully to ${node_path_1.default.resolve(outputPath)}.`);
         }
         catch (e) {
@@ -37,6 +64,32 @@ class ExtractedImage {
             }
         }
     }
+    /**
+     * Attempts to saves the document to a file synchronously.
+     * Throws an error if the file extension is not supported or if the file could not be saved to disk for some reason.
+     *
+     * @param outputPath Path to save the file to.
+     */
+    saveToFile(outputPath) {
+        const fileExt = node_path_1.default.extname(outputPath).toLowerCase();
+        if (fileExt !== ".pdf") {
+            throw new errors_1.MindeeError(`Unsupported file extension: ${fileExt}. For image formats, use saveToFileAsync() instead.`);
+        }
+        else {
+            try {
+                (0, node_fs_1.writeFileSync)(node_path_1.default.resolve(outputPath), this.buffer);
+                logger_1.logger.info(`File saved successfully to ${node_path_1.default.resolve(outputPath)}.`);
+            }
+            catch (e) {
+                if (e instanceof TypeError) {
+                    throw new errors_1.MindeeError("Invalid path/filename provided.");
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+    }
     /**
      * Return the file as a Mindee-compatible BufferInput source.
      *

package/src/imageOperations/common/imageExtractor.js

@@ -12,6 +12,9 @@ const geometry_1 = require("../../geometry");
 async function extractFromPage(pdfPage, polygons) {
     const { width, height } = pdfPage.getSize();
     const extractedElements = [];
+    // Manual upscale.
+    // Fixes issues with the OCR.
+    const qualityScale = 300 / 72;
     for (const polygon of polygons) {
         const tempPdf = await pdf_lib_1.PDFDocument.create();
         const newWidth = width * ((0, geometry_1.getMinMaxX)(polygon).max - (0, geometry_1.getMinMaxX)(polygon).min);
@@ -22,10 +25,16 @@ async function extractFromPage(pdfPage, polygons) {
             top: height - ((0, geometry_1.getMinMaxY)(polygon).min * height),
             bottom: height - ((0, geometry_1.getMinMaxY)(polygon).max * height),
         });
-        const samplePage = tempPdf.addPage([newWidth, newHeight]);
+        const samplePage = tempPdf.addPage([newWidth * qualityScale, newHeight * qualityScale]);
+        samplePage.drawRectangle({
+            x: 0,
+            y: 0,
+            width: newWidth * qualityScale,
+            height: newHeight * qualityScale,
+        });
         samplePage.drawPage(cropped, {
-            width: newWidth,
-            height: newHeight,
+            width: newWidth * qualityScale,
+            height: newHeight * qualityScale,
         });
         extractedElements.push(await tempPdf.save());
     }

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/input/sources/localInputSource.d.ts

@@ -1,5 +1,6 @@
 import { PageOptions } from "../pageOptions";
 import { InputSource, InputConstructor } from "./inputSource";
+export declare const MIMETYPES: Map<string, string>;
 export declare abstract class LocalInputSource extends InputSource {
     inputType: string;
     filename: string;

package/src/input/sources/localInputSource.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalInputSource = void 0;
+exports.LocalInputSource = exports.MIMETYPES = void 0;
 const handler_1 = require("../../errors/handler");
 const logger_1 = require("../../logger");
 const imageOperations_1 = require("../../imageOperations");
@@ -45,7 +45,7 @@ const path_1 = __importDefault(require("path"));
 const fileType = __importStar(require("file-type"));
 const pdf_2 = require("../../pdf");
 const inputSource_1 = require("./inputSource");
-const MIMETYPES = new Map([
+exports.MIMETYPES = new Map([
     [".pdf", "application/pdf"],
     [".heic", "image/heic"],
     [".jpg", "image/jpeg"],
@@ -85,7 +85,7 @@ class LocalInputSource extends inputSource_1.InputSource {
         let mimeType;
         const fileExt = path_1.default.extname(this.filename);
         if (fileExt) {
-            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+            mimeType = exports.MIMETYPES.get(fileExt.toLowerCase()) || "";
         }
         else {
             const guess = await fileType.fromBuffer(this.fileObject);
@@ -97,7 +97,7 @@ class LocalInputSource extends inputSource_1.InputSource {
             }
         }
         if (!mimeType) {
-            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const allowed = Array.from(exports.MIMETYPES.keys()).join(", ");
             const err = new Error(`Invalid file type, must be one of ${allowed}.`);
             handler_1.errorHandler.throw(err);
         }

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;