mindee 3.10.2 → 4.0.0

package/src/parsing/common/ocrPage.js

@@ -0,0 +1,66 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _OcrPage_instances, _OcrPage_areWordsOnSameLine, _OcrPage_toLines;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OcrPage = void 0;
+const geometry_1 = require("../../geometry");
+class OcrPage {
+    constructor(rawPrediction) {
+        _OcrPage_instances.add(this);
+        /** Flat list of all words read */
+        this.allWords = [];
+        /** List of words by which line they are on */
+        this.allLines = [];
+        const allWords = [];
+        rawPrediction["all_words"] &&
+            rawPrediction["all_words"].forEach((word) => {
+                allWords.push(word);
+            });
+        this.allWords = allWords.sort((word1, word2) => (0, geometry_1.compareOnY)(word1.polygon, word2.polygon));
+    }
+    /**
+     * Get all words on the page as ordered lines
+     * @returns Sorted lines on the pages
+     */
+    getAllLines() {
+        if (!this.allLines || this.allLines.length === 0) {
+            this.allLines = __classPrivateFieldGet(this, _OcrPage_instances, "m", _OcrPage_toLines).call(this);
+        }
+        return this.allLines;
+    }
+    toString() {
+        return this.getAllLines()
+            .map((line) => line.map((word) => word.text).join(" "))
+            .join("\n");
+    }
+}
+exports.OcrPage = OcrPage;
+_OcrPage_instances = new WeakSet(), _OcrPage_areWordsOnSameLine = function _OcrPage_areWordsOnSameLine(currentWord, nextWord) {
+    const currentInNext = (0, geometry_1.isPointInPolygonY)((0, geometry_1.getCentroid)(currentWord.polygon), nextWord.polygon);
+    const nextInCurrent = (0, geometry_1.isPointInPolygonY)((0, geometry_1.getCentroid)(nextWord.polygon), currentWord.polygon);
+    return nextInCurrent || currentInNext;
+}, _OcrPage_toLines = function _OcrPage_toLines() {
+    const lines = [];
+    const lineIdx = [];
+    this.allWords.forEach((current, idxCurrent) => {
+        if (!lineIdx.includes(idxCurrent)) {
+            lines.push([current]);
+            lineIdx.push(idxCurrent);
+        }
+        this.allWords.forEach((next, idxNext) => {
+            if (idxCurrent === idxNext || lineIdx.includes(idxNext)) {
+                return;
+            }
+            if (__classPrivateFieldGet(this, _OcrPage_instances, "m", _OcrPage_areWordsOnSameLine).call(this, current, next)) {
+                lineIdx.push(idxNext);
+                lines[lines.length - 1].push(next);
+            }
+        });
+    });
+    lines.forEach((line) => line.sort((word1, word2) => (0, geometry_1.compareOnX)(word1.polygon, word2.polygon)));
+    return lines;
+};

package/src/{fields → parsing/common}/orientation.d.ts

@@ -1,4 +1,4 @@
-import { BaseField, BaseFieldConstructor } from "./base";
+import { BaseField, BaseFieldConstructor } from "../standard";
 interface OrientationFieldConstructor extends BaseFieldConstructor {
     pageId: number;
 }
@@ -13,7 +13,7 @@ export declare class OrientationField extends BaseField {
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      * @param {Integer} pageId - Page ID for multi-page document
      */
     constructor({ prediction, valueKey, reconstructed, pageId, }: OrientationFieldConstructor);

package/src/{fields → parsing/common}/orientation.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OrientationField = void 0;
-const base_1 = require("./base");
+const standard_1 = require("../standard");
 /**
  * The clockwise rotation to apply (in degrees) to make the image upright.
  */
-class OrientationField extends base_1.BaseField {
+class OrientationField extends standard_1.BaseField {
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      * @param {Integer} pageId - Page ID for multi-page document
      */
-    constructor({ prediction, valueKey = "value", reconstructed = false, pageId, }) {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
         super({ prediction, valueKey, reconstructed });
         const orientations = [0, 90, 180, 270];
         this.pageId = pageId;

package/src/parsing/common/page.d.ts

@@ -0,0 +1,12 @@
+import { Extras } from "./extras/extras";
+import { OrientationField } from "./orientation";
+import { Prediction } from "./prediction";
+import { StringDict } from "./stringDict";
+export declare class Page<T extends Prediction> {
+    id: number;
+    orientation?: OrientationField;
+    prediction: T;
+    extras?: Extras;
+    constructor(predictionType: new (rawPrediction: StringDict, pageId: number) => T, rawPrediction: StringDict, pageId: number, orientation?: StringDict);
+    toString(): string;
+}

package/src/parsing/common/page.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const cropperExtra_1 = require("./extras/cropperExtra");
+const extras_1 = require("./extras/extras");
+const orientation_1 = require("./orientation");
+class Page {
+    constructor(predictionType, rawPrediction, pageId, orientation) {
+        if (pageId !== undefined && orientation !== undefined) {
+            this.orientation = new orientation_1.OrientationField({
+                prediction: orientation,
+                pageId: pageId,
+            });
+        }
+        else {
+            orientation = undefined;
+        }
+        this.id = pageId;
+        this.prediction = new predictionType(rawPrediction["prediction"], pageId);
+        if (rawPrediction["extras"] &&
+            Object.keys(rawPrediction["extras"].length > 0)) {
+            const extras = {};
+            Object.entries(rawPrediction["extras"]).forEach(([extraKey, extraValue]) => {
+                switch (extraKey) {
+                    case "cropper":
+                        extras["cropper"] = new cropperExtra_1.CropperExtra(extraValue);
+                }
+            });
+            this.extras = new extras_1.Extras(extras);
+        }
+    }
+    toString() {
+        const title = `Page ${this.id}`;
+        return `${title}
+${"-".repeat(title.length)}
+${this.prediction.toString()}
+`;
+    }
+}
+exports.Page = Page;

package/src/parsing/common/predictResponse.d.ts

@@ -0,0 +1,6 @@
+import { ApiResponse } from "./apiResponse";
+import { Document, Inference, StringDict } from ".";
+export declare class PredictResponse<T extends Inference> extends ApiResponse {
+    document: Document<T>;
+    constructor(inferenceClass: new (rawPrediction: StringDict) => T, rawPrediction: StringDict);
+}

package/src/parsing/common/predictResponse.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PredictResponse = void 0;
+const apiResponse_1 = require("./apiResponse");
+const _1 = require(".");
+class PredictResponse extends apiResponse_1.ApiResponse {
+    constructor(inferenceClass, rawPrediction) {
+        super(rawPrediction);
+        this.document = new _1.Document(inferenceClass, rawPrediction["document"]);
+    }
+}
+exports.PredictResponse = PredictResponse;

package/src/parsing/common/prediction.d.ts

@@ -0,0 +1,2 @@
+export declare class Prediction {
+}

package/src/parsing/common/prediction.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Prediction = void 0;
+class Prediction {
+}
+exports.Prediction = Prediction;

package/src/parsing/common/product.d.ts

@@ -0,0 +1,4 @@
+export interface Product {
+    name?: string;
+    version?: string;
+}

package/src/parsing/common/product.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/parsing/common/stringDict.d.ts

@@ -0,0 +1,3 @@
+export type StringDict = {
+    [index: string]: any;
+};

package/src/parsing/common/stringDict.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/parsing/common/summaryHelper.d.ts

@@ -0,0 +1,8 @@
+export declare function cleanOutString(outStr: string): string;
+/**
+ *
+ * @param columnSizes Size of each column in the table
+ * @param separator character for a separator
+ * @returns A separator for table lines
+ */
+export declare function lineSeparator(columnSizes: number[], separator: string): string;

package/src/parsing/common/summaryHelper.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineSeparator = exports.cleanOutString = void 0;
+function cleanOutString(outStr) {
+    const lines = / \n/gm;
+    return outStr.replace(lines, "\n");
+}
+exports.cleanOutString = cleanOutString;
+/**
+ *
+ * @param columnSizes Size of each column in the table
+ * @param separator character for a separator
+ * @returns A separator for table lines
+ */
+function lineSeparator(columnSizes, separator) {
+    let outStr = "  +";
+    columnSizes.forEach((size) => {
+        outStr += separator.repeat(size) + "+";
+    });
+    return outStr;
+}
+exports.lineSeparator = lineSeparator;

package/src/parsing/custom/classificationField.d.ts

@@ -0,0 +1,16 @@
+import { StringDict } from "../common";
+export declare class ClassificationField {
+    /** The value for the classification. */
+    value: string;
+    /**
+     * The confidence score of the prediction.
+     * Note: Score is calculated on **word selection**, not its textual content (OCR).
+     */
+    confidence: number;
+    pageId?: number;
+    constructor({ prediction, pageId, }: {
+        prediction: StringDict;
+        pageId?: number;
+    });
+    toString(): string;
+}

package/src/parsing/custom/classificationField.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassificationField = void 0;
+class ClassificationField {
+    constructor({ prediction, pageId, }) {
+        this.value = prediction["value"];
+        this.confidence = prediction["confidence"];
+        this.pageId ?? (this.pageId = pageId);
+    }
+    toString() {
+        return `${this.value}`;
+    }
+}
+exports.ClassificationField = ClassificationField;

package/src/parsing/custom/index.d.ts

@@ -0,0 +1,3 @@
+export { Line, LineItems, getLineItems } from "./lineItems";
+export { ClassificationField } from "./classificationField";
+export { ListField, ListFieldValue } from "./listField";

package/src/parsing/custom/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListFieldValue = exports.ListField = exports.ClassificationField = exports.getLineItems = exports.LineItems = exports.Line = void 0;
+var lineItems_1 = require("./lineItems");
+Object.defineProperty(exports, "Line", { enumerable: true, get: function () { return lineItems_1.Line; } });
+Object.defineProperty(exports, "LineItems", { enumerable: true, get: function () { return lineItems_1.LineItems; } });
+Object.defineProperty(exports, "getLineItems", { enumerable: true, get: function () { return lineItems_1.getLineItems; } });
+var classificationField_1 = require("./classificationField");
+Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return classificationField_1.ClassificationField; } });
+var listField_1 = require("./listField");
+Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return listField_1.ListField; } });
+Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return listField_1.ListFieldValue; } });

package/src/{documents/custom/lineitems.d.ts → parsing/custom/lineItems.d.ts}

@@ -1,9 +1,9 @@
 import { BBox, Polygon } from "../../geometry";
-import { ListField, ListFieldValue } from "./fields";
+import { ListField, ListFieldValue } from "./listField";
 export declare class Line {
     /**
      * Number of the current line.
-     * Starts to 1.
+     * Starts at 1.
      */
     rowNumber: number;
     /**
@@ -16,7 +16,7 @@ export declare class Line {
     bbox: BBox;
     /**
      * The height tolerance used to build the line.
-     * It helps when the height of an expected line can vary.
+     * It helps when the height of a line can vary unexpectedly.
      */
     heightTolerance: number;
     constructor(rowNumber: number, heightTolerance: number);
@@ -38,4 +38,4 @@ export declare class LineItems {
     rows: Line[];
     constructor(lines: Line[]);
 }
-export declare function getLineItems(anchorNames: string[], heigthLineTolerance: number, fieldNamesTargeted: string[], fields: Map<string, ListField>): LineItems;
+export declare function getLineItems(anchorNames: string[], heightLineTolerance: number, fieldNamesTargeted: string[], fields: Map<string, ListField>): LineItems;

package/src/{documents/custom/lineitems.js → parsing/custom/lineItems.js}

@@ -4,8 +4,7 @@ exports.getLineItems = exports.LineItems = exports.Line = void 0;
 const handler_1 = require("../../errors/handler");
 const errors_1 = require("../../errors");
 const geometry_1 = require("../../geometry");
-const fields_1 = require("./fields");
-const math_1 = require("../../math");
+const listField_1 = require("./listField");
 class Line {
     constructor(rowNumber, heightTolerance) {
         this.rowNumber = rowNumber;
@@ -29,7 +28,10 @@ class Line {
      * Check if the bbox fits the current line.
      */
     contains(bbox) {
-        return (0, math_1.precisionEquals)(this.bbox[1], bbox[1], this.heightTolerance);
+        if (Math.abs(bbox[1] - this.bbox[1]) <= this.heightTolerance) {
+            return true;
+        }
+        return Math.abs(this.bbox[1] - bbox[1]) <= this.heightTolerance;
     }
     updateField(name, fieldValue) {
         if (!this.fields.has(name)) {
@@ -48,7 +50,7 @@ class Line {
                 existingField.polygon,
                 fieldValue.polygon,
             ]);
-            this.fields.set(name, new fields_1.ListFieldValue({
+            this.fields.set(name, new listField_1.ListFieldValue({
                 content: mergedContent,
                 confidence: existingField.confidence * fieldValue.confidence,
                 polygon: (0, geometry_1.getBoundingBoxFromBBox)(mergedBbox),
@@ -64,10 +66,10 @@ class LineItems {
     }
 }
 exports.LineItems = LineItems;
-function getLineItems(anchorNames, heigthLineTolerance, fieldNamesTargeted, fields) {
+function getLineItems(anchorNames, heightLineTolerance, fieldNamesTargeted, fields) {
     const fieldsToTransformIntoLines = new Map([...fields].filter(([k]) => fieldNamesTargeted.includes(k)));
     const anchorName = findBestAnchor(anchorNames, fieldsToTransformIntoLines);
-    const lineItemsPrepared = prepare(anchorName, fieldsToTransformIntoLines, heigthLineTolerance);
+    const lineItemsPrepared = prepare(anchorName, fieldsToTransformIntoLines, heightLineTolerance);
     lineItemsPrepared.rows.forEach((currentLine) => {
         fieldsToTransformIntoLines.forEach((field, fieldName) => {
             field.values.forEach((listFieldValue) => {
@@ -97,14 +99,14 @@ function findBestAnchor(possibleAnchorNames, fields) {
     }
     return anchorName;
 }
-function prepare(anchorName, fields, heigthLineTolerance) {
+function prepare(anchorName, fields, heightLineTolerance) {
     const lineItemsPrepared = [];
     const anchorField = fields.get(anchorName);
     if (anchorField === undefined || anchorField.values.length === 0) {
         handler_1.errorHandler.throw(new errors_1.MindeeError("No lines have been detected."));
     }
     let currentLineNumber = 1;
-    let currentLine = new Line(currentLineNumber, heigthLineTolerance);
+    let currentLine = new Line(currentLineNumber, heightLineTolerance);
     if (anchorField !== undefined) {
         let currentValue = anchorField.values[0];
         currentLine.extendWith(currentValue.polygon);
@@ -114,7 +116,7 @@ function prepare(anchorName, fields, heigthLineTolerance) {
             if (!currentLine.contains(currentFieldBbox)) {
                 lineItemsPrepared.push(currentLine);
                 currentLineNumber++;
-                currentLine = new Line(currentLineNumber, heigthLineTolerance);
+                currentLine = new Line(currentLineNumber, heightLineTolerance);
             }
             currentLine.extendWithBbox(currentFieldBbox);
         }

package/src/{documents/custom/fields.d.ts → parsing/custom/listField.d.ts}

@@ -1,19 +1,6 @@
-import { StringDict } from "../../fields/base";
-import { FieldConstructor } from "../../fields/field";
+import { FieldConstructor } from "../standard";
 import { Polygon } from "../../geometry";
-export declare class ClassificationField {
-    /** The value for the classification. */
-    value: string;
-    /**
-     * The confidence score of the prediction.
-     * Note: Score is calculated on **word selection**, not its textual content (OCR).
-     */
-    confidence: number;
-    constructor({ prediction }: {
-        prediction: StringDict;
-    });
-    toString(): string;
-}
+import { StringDict } from "../common";
 export declare class ListFieldValue {
     /** Extracted content of the prediction */
     content: string | number;
@@ -42,7 +29,7 @@ export declare class ListField {
     reconstructed: boolean;
     /** The document page on which the information was found. */
     pageId: number;
-    constructor({ prediction, reconstructed, pageId }: FieldConstructor);
+    constructor({ prediction, reconstructed, pageId, }: FieldConstructor);
     contentsList(): Array<string | number>;
     contentsString(separator?: string): string;
     toString(): string;

package/src/{documents/custom/fields.js → parsing/custom/listField.js}

@@ -1,17 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListField = exports.ListFieldValue = exports.ClassificationField = void 0;
+exports.ListField = exports.ListFieldValue = void 0;
 const geometry_1 = require("../../geometry");
-class ClassificationField {
-    constructor({ prediction }) {
-        this.value = prediction["value"];
-        this.confidence = prediction["confidence"];
-    }
-    toString() {
-        return `${this.value}`;
-    }
-}
-exports.ClassificationField = ClassificationField;
 class ListFieldValue {
     constructor(prediction) {
         /**
@@ -28,7 +18,7 @@ class ListFieldValue {
         this.confidence = prediction["confidence"];
         if (prediction["polygon"]) {
             this.polygon = prediction["polygon"];
-            this.bbox = (0, geometry_1.getBoundingBox)(prediction.polygon);
+            this.bbox = (0, geometry_1.getBoundingBox)(prediction["polygon"]);
         }
     }
     toString() {
@@ -37,12 +27,12 @@ class ListFieldValue {
 }
 exports.ListFieldValue = ListFieldValue;
 class ListField {
-    constructor({ prediction, reconstructed = false, pageId }) {
+    constructor({ prediction = {}, reconstructed = false, pageId, }) {
         this.values = [];
         this.confidence = prediction["confidence"];
         this.reconstructed = reconstructed;
         this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
-        if (Object.prototype.hasOwnProperty.call(prediction, "values")) {
+        if (prediction["values"] !== undefined) {
             prediction["values"].forEach((field) => {
                 this.values.push(new ListFieldValue(field));
             });

package/src/parsing/index.d.ts

@@ -0,0 +1,3 @@
+export * as common from "./common";
+export * as custom from "./custom";
+export * as standard from "./standard";

package/src/parsing/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.standard = exports.custom = exports.common = void 0;
+exports.common = __importStar(require("./common"));
+exports.custom = __importStar(require("./custom"));
+exports.standard = __importStar(require("./standard"));

package/src/{fields → parsing/standard}/amount.d.ts

@@ -3,13 +3,13 @@ export declare function floatToString(value: number): string;
 /**
  * A field containing an amount value.
  */
-export declare class Amount extends Field {
+export declare class AmountField extends Field {
     /** The value. */
     value?: number;
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      * @param {Integer} pageId - Page ID for multi-page document
      */
     constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);

package/src/{fields → parsing/standard}/amount.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Amount = exports.floatToString = void 0;
+exports.AmountField = exports.floatToString = void 0;
 const field_1 = require("./field");
 function floatToString(value) {
     return value.toLocaleString(undefined, {
@@ -13,14 +13,14 @@ exports.floatToString = floatToString;
 /**
  * A field containing an amount value.
  */
-class Amount extends field_1.Field {
+class AmountField extends field_1.Field {
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      * @param {Integer} pageId - Page ID for multi-page document
      */
-    constructor({ prediction, valueKey = "value", reconstructed = false, pageId = undefined, }) {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
         super({ prediction, valueKey, reconstructed, pageId });
         /** The value. */
         this.value = undefined;
@@ -37,4 +37,4 @@ class Amount extends field_1.Field {
         return "";
     }
 }
-exports.Amount = Amount;
+exports.AmountField = AmountField;

package/src/{fields → parsing/standard}/base.d.ts

@@ -1,10 +1,9 @@
-export type StringDict = {
-    [index: string]: any;
-};
+import { StringDict } from "../common";
 export interface BaseFieldConstructor {
     prediction: StringDict;
     valueKey?: string;
     reconstructed?: boolean;
+    pageId?: number;
 }
 /**
  * Base class for most fields.
@@ -14,12 +13,13 @@ export declare class BaseField {
     value?: string | number;
     /** `true` when the field was reconstructed or computed using other fields. */
     reconstructed: boolean;
+    pageId?: number;
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      */
-    constructor({ prediction, valueKey, reconstructed, }: BaseFieldConstructor);
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
     compare(other: BaseField): boolean;
     /**
      * @param {BaseField[]} array - Array of Fields

package/src/{fields → parsing/standard}/base.js

@@ -8,9 +8,9 @@ class BaseField {
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
      */
-    constructor({ prediction, valueKey = "value", reconstructed = false, }) {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
         /** The value. */
         this.value = undefined;
         this.reconstructed = reconstructed;
@@ -19,6 +19,7 @@ class BaseField {
             valueKey in prediction &&
             prediction[valueKey] !== null) {
             this.value = prediction[valueKey];
+            this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
         }
     }
     compare(other) {

package/src/{fields → parsing/standard}/classification.d.ts

@@ -7,5 +7,5 @@ export declare class ClassificationField extends BaseField {
     confidence: number;
     /** The classification. */
     value?: string;
-    constructor({ prediction, valueKey, reconstructed, }: BaseFieldConstructor);
+    constructor({ prediction, valueKey, reconstructed, pageId, }: BaseFieldConstructor);
 }

package/src/{fields → parsing/standard}/classification.js

@@ -6,9 +6,9 @@ const base_1 = require("./base");
  * Represents a classifier value.
  */
 class ClassificationField extends base_1.BaseField {
-    constructor({ prediction, valueKey = "value", reconstructed = false, }) {
-        super({ prediction, valueKey, reconstructed });
-        this.confidence = prediction.confidence ? prediction.confidence : 0.0;
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.confidence = prediction["confidence"] ? prediction["confidence"] : 0.0;
     }
 }
 exports.ClassificationField = ClassificationField;

package/src/{fields → parsing/standard}/companyRegistration.d.ts

@@ -2,7 +2,7 @@ import { Field, FieldConstructor } from "./field";
 /**
  * A company registration item.
  */
-export declare class CompanyRegistration extends Field {
+export declare class CompanyRegistrationField extends Field {
     /** Registration identifier. */
     value?: string;
     /** Type of company registration. */