mindee 3.10.2 → 4.0.1

package/src/parsing/standard/companyRegistration.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyRegistrationField = void 0;
+const field_1 = require("./field");
+/**
+ * A company registration item.
+ */
+class CompanyRegistrationField extends field_1.Field {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.type = prediction["type"];
+    }
+}
+exports.CompanyRegistrationField = CompanyRegistrationField;

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

@@ -10,7 +10,7 @@ export declare class DateField extends 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, reconstructed, pageId, }: FieldConstructor);

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

@@ -9,10 +9,10 @@ class DateField 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, }) {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
         super({ prediction, valueKey, reconstructed, pageId });
         if (typeof this.value === "string") {
             this.dateObject = new Date(this.value);

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

@@ -1,5 +1,6 @@
-import { StringDict, BaseField } from "./base";
-import { Polygon, BoundingBox } from "../geometry";
+import { BaseField } from "./base";
+import { Polygon, BoundingBox } from "../../geometry";
+import { StringDict } from "../common";
 export interface FieldConstructor {
     prediction: StringDict;
     valueKey?: string;
@@ -20,8 +21,6 @@ export declare class Field extends BaseField {
      * the field in the document.
      */
     polygon: Polygon;
-    /** The document page on which the information was found. */
-    pageId: number;
     /** The confidence score of the prediction. */
     confidence: number;
     /**

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Field = void 0;
 const base_1 = require("./base");
-const geometry_1 = require("../geometry");
+const geometry_1 = require("../../geometry");
 /**
  * A basic field with position and page information.
  */
@@ -14,17 +14,16 @@ class Field extends base_1.BaseField {
      * @param {Integer} pageId - Page ID for multi-page document
      * @param {Array<String>} extraFields - Extra fields to get from the prediction and to set as attribute of the Field
      */
-    constructor({ prediction, valueKey = "value", reconstructed = false, pageId, }) {
-        super({ prediction, valueKey, reconstructed });
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
         /**
          * Contains the relative vertices coordinates (points) of a polygon containing
          * the field in the document.
          */
         this.polygon = [];
-        this.pageId = pageId !== undefined ? pageId : prediction["page_id"];
-        this.confidence = prediction.confidence ? prediction.confidence : 0.0;
-        if (prediction.polygon) {
-            this.polygon = prediction.polygon;
+        this.confidence = prediction["confidence"] ? prediction["confidence"] : 0.0;
+        if (prediction["polygon"]) {
+            this.polygon = prediction["polygon"];
         }
         this.boundingBox = (0, geometry_1.getBoundingBox)(this.polygon);
     }

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

@@ -0,0 +1,12 @@
+export { ClassificationField } from "./classification";
+export { Taxes, TaxField } from "./tax";
+export { PaymentDetailsField } from "./paymentDetails";
+export { LocaleField } from "./locale";
+export { AmountField, floatToString } from "./amount";
+export { DateField } from "./date";
+export { BaseField, BaseFieldConstructor } from "./base";
+export { Word } from "./word";
+export { CompanyRegistrationField } from "./companyRegistration";
+export { PositionField } from "./position";
+export { StringField } from "./text";
+export { Field, FieldConstructor } from "./field";

package/src/parsing/standard/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = exports.StringField = exports.PositionField = exports.CompanyRegistrationField = exports.BaseField = exports.DateField = exports.floatToString = exports.AmountField = exports.LocaleField = exports.PaymentDetailsField = exports.TaxField = exports.Taxes = exports.ClassificationField = void 0;
+var classification_1 = require("./classification");
+Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return classification_1.ClassificationField; } });
+var tax_1 = require("./tax");
+Object.defineProperty(exports, "Taxes", { enumerable: true, get: function () { return tax_1.Taxes; } });
+Object.defineProperty(exports, "TaxField", { enumerable: true, get: function () { return tax_1.TaxField; } });
+var paymentDetails_1 = require("./paymentDetails");
+Object.defineProperty(exports, "PaymentDetailsField", { enumerable: true, get: function () { return paymentDetails_1.PaymentDetailsField; } });
+var locale_1 = require("./locale");
+Object.defineProperty(exports, "LocaleField", { enumerable: true, get: function () { return locale_1.LocaleField; } });
+var amount_1 = require("./amount");
+Object.defineProperty(exports, "AmountField", { enumerable: true, get: function () { return amount_1.AmountField; } });
+Object.defineProperty(exports, "floatToString", { enumerable: true, get: function () { return amount_1.floatToString; } });
+var date_1 = require("./date");
+Object.defineProperty(exports, "DateField", { enumerable: true, get: function () { return date_1.DateField; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseField", { enumerable: true, get: function () { return base_1.BaseField; } });
+var companyRegistration_1 = require("./companyRegistration");
+Object.defineProperty(exports, "CompanyRegistrationField", { enumerable: true, get: function () { return companyRegistration_1.CompanyRegistrationField; } });
+var position_1 = require("./position");
+Object.defineProperty(exports, "PositionField", { enumerable: true, get: function () { return position_1.PositionField; } });
+var text_1 = require("./text");
+Object.defineProperty(exports, "StringField", { enumerable: true, get: function () { return text_1.StringField; } });
+var field_1 = require("./field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });

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

@@ -2,22 +2,22 @@ import { BaseField, BaseFieldConstructor } from "./base";
 /**
  * The locale detected on the document.
  */
-export declare class Locale extends BaseField {
+export declare class LocaleField extends BaseField {
     /** Locale in ISO format. */
     value?: string;
     /** The confidence score of the prediction. */
     confidence: number;
     /** ISO 639-1 language code */
     language?: string;
-    /** ISO 3166-1 alpha-2 country code */
+    /** ISO 3166-1 alpha-2 (or alpha-3) country code */
     country?: string;
     /** ISO 4217 currency code */
     currency?: string;
     /**
      * @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, reconstructed }: BaseFieldConstructor);
+    constructor({ prediction, reconstructed, pageId, }: BaseFieldConstructor);
     toString(): string;
 }

package/src/parsing/standard/locale.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocaleField = void 0;
+const base_1 = require("./base");
+/**
+ * The locale detected on the document.
+ */
+class LocaleField extends base_1.BaseField {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict
+     * @param {boolean} reconstructed - Is the object reconstructed (not extracted by the API)
+     */
+    constructor({ prediction = {}, reconstructed = false, pageId = undefined, }) {
+        const valueKey = prediction["value"] !== undefined ? "value" : "language";
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.confidence = prediction["confidence"] ? prediction["confidence"] : 0.0;
+        this.language =
+            prediction["language"] !== undefined ? prediction["language"] : undefined;
+        this.country =
+            prediction["country"] !== undefined ? prediction["country"] : undefined;
+        this.currency =
+            prediction["currency"] !== undefined ? prediction["currency"] : undefined;
+    }
+    toString() {
+        let outStr = "";
+        if (this.value) {
+            outStr += `${this.value}; `;
+        }
+        if (this.language) {
+            outStr += `${this.language}; `;
+        }
+        if (this.country) {
+            outStr += `${this.country}; `;
+        }
+        if (this.currency) {
+            outStr += `${this.currency};`;
+        }
+        return outStr.trimEnd();
+    }
+}
+exports.LocaleField = LocaleField;

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

@@ -1,4 +1,4 @@
-import { StringDict } from "./base";
+import { StringDict } from "../common";
 import { Field } from "./field";
 interface PaymentDetailsConstructor {
     prediction: StringDict;
@@ -13,7 +13,7 @@ interface PaymentDetailsConstructor {
 /**
  * Information on a single payment.
  */
-export declare class PaymentDetails extends Field {
+export declare class PaymentDetailsField extends Field {
     #private;
     /** Synonym for the `iban` property */
     value?: string | undefined;
@@ -32,7 +32,7 @@ export declare class PaymentDetails extends Field {
      * @param {String} ibanKey - Key to use to get the IBAN in the prediction dict
      * @param {String} routingNumberKey - Key to use to get the routing number in the prediction dict
      * @param {String} swiftKey - Key to use to get the SWIFT 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, accountNumberKey, ibanKey, routingNumberKey, swiftKey, reconstructed, pageId, }: PaymentDetailsConstructor);

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

@@ -4,14 +4,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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 _a, _PaymentDetails_isKeySet;
+var _a, _PaymentDetailsField_isKeySet;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PaymentDetails = void 0;
+exports.PaymentDetailsField = void 0;
 const field_1 = require("./field");
 /**
  * Information on a single payment.
  */
-class PaymentDetails extends field_1.Field {
+class PaymentDetailsField extends field_1.Field {
     /**
      * @param {Object} prediction - Prediction object from HTTP response
      * @param {String} valueKey - Key to use in the prediction dict to get the iban
@@ -19,25 +19,25 @@ class PaymentDetails extends field_1.Field {
      * @param {String} ibanKey - Key to use to get the IBAN in the prediction dict
      * @param {String} routingNumberKey - Key to use to get the routing number in the prediction dict
      * @param {String} swiftKey - Key to use to get the SWIFT 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 = "iban", accountNumberKey = "account_number", ibanKey = "iban", routingNumberKey = "routing_number", swiftKey = "swift", reconstructed = false, pageId = undefined, }) {
+    constructor({ prediction = {}, valueKey = "iban", accountNumberKey = "account_number", ibanKey = "iban", routingNumberKey = "routing_number", swiftKey = "swift", reconstructed = false, pageId = undefined, }) {
         super({ prediction, valueKey, reconstructed, pageId });
         this.accountNumber = undefined;
         this.iban = undefined;
         this.routingNumber = undefined;
         this.swift = undefined;
-        if (__classPrivateFieldGet(PaymentDetails, _a, "m", _PaymentDetails_isKeySet).call(PaymentDetails, prediction[accountNumberKey])) {
+        if (__classPrivateFieldGet(PaymentDetailsField, _a, "m", _PaymentDetailsField_isKeySet).call(PaymentDetailsField, prediction[accountNumberKey])) {
             this.accountNumber = prediction[accountNumberKey];
         }
-        if (__classPrivateFieldGet(PaymentDetails, _a, "m", _PaymentDetails_isKeySet).call(PaymentDetails, prediction[ibanKey])) {
+        if (__classPrivateFieldGet(PaymentDetailsField, _a, "m", _PaymentDetailsField_isKeySet).call(PaymentDetailsField, prediction[ibanKey])) {
             this.iban = prediction[ibanKey];
         }
-        if (__classPrivateFieldGet(PaymentDetails, _a, "m", _PaymentDetails_isKeySet).call(PaymentDetails, prediction[routingNumberKey])) {
+        if (__classPrivateFieldGet(PaymentDetailsField, _a, "m", _PaymentDetailsField_isKeySet).call(PaymentDetailsField, prediction[routingNumberKey])) {
             this.routingNumber = prediction[routingNumberKey];
         }
-        if (__classPrivateFieldGet(PaymentDetails, _a, "m", _PaymentDetails_isKeySet).call(PaymentDetails, prediction[swiftKey])) {
+        if (__classPrivateFieldGet(PaymentDetailsField, _a, "m", _PaymentDetailsField_isKeySet).call(PaymentDetailsField, prediction[swiftKey])) {
             this.swift = prediction[swiftKey];
         }
     }
@@ -58,7 +58,7 @@ class PaymentDetails extends field_1.Field {
         return str;
     }
 }
-exports.PaymentDetails = PaymentDetails;
-_a = PaymentDetails, _PaymentDetails_isKeySet = function _PaymentDetails_isKeySet(value) {
+exports.PaymentDetailsField = PaymentDetailsField;
+_a = PaymentDetailsField, _PaymentDetailsField_isKeySet = function _PaymentDetailsField_isKeySet(value) {
     return typeof value === "string" && value !== "N/A";
 };

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

@@ -1,5 +1,5 @@
-import { StringDict } from "./base";
-import { Polygon } from "../geometry";
+import { StringDict } from "../common";
+import { Polygon } from "../../geometry";
 export interface PositionFieldConstructor {
     prediction: StringDict;
     valueKey?: string;

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

@@ -5,12 +5,12 @@ exports.PositionField = void 0;
  * A field indicating a position or area on the document.
  */
 class PositionField {
-    constructor({ prediction, pageId }) {
+    constructor({ prediction = {}, pageId }) {
         this.pageId = pageId;
-        this.boundingBox = prediction.bounding_box;
-        this.polygon = prediction.polygon;
-        this.quadrangle = prediction.quadrangle;
-        this.rectangle = prediction.rectangle;
+        this.boundingBox = prediction["bounding_box"];
+        this.polygon = prediction["polygon"];
+        this.quadrangle = prediction["quadrangle"];
+        this.rectangle = prediction["rectangle"];
     }
     toString() {
         return `Polygon with ${this.polygon.length} points.`;

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

@@ -1,4 +1,4 @@
-import { StringDict } from "./base";
+import { StringDict } from "../common";
 import { Field } from "./field";
 interface TaxConstructor {
     prediction: StringDict;
@@ -30,7 +30,7 @@ export declare class TaxField extends Field {
      * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
      * @param {String} codeKey - Key to use to get the tax code in the prediction dict
      * @param {String} baseKey - Key to use to get the base tax 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} pageNumber - Page ID for multi-page document
      */
     constructor({ prediction, valueKey, rateKey, codeKey, baseKey, reconstructed, pageId, }: TaxConstructor);
@@ -48,7 +48,7 @@ export declare class TaxField extends Field {
  */
 export declare class Taxes extends Array<TaxField> {
     #private;
-    init(prediction: StringDict[], pageId: number | undefined): this;
+    init(prediction: StringDict[] | undefined, pageId: number | undefined): this;
     toString(): string;
 }
 export {};

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

@@ -19,10 +19,10 @@ class TaxField extends field_1.Field {
      * @param {String} rateKey - Key to use to get the tax rate in the prediction dict
      * @param {String} codeKey - Key to use to get the tax code in the prediction dict
      * @param {String} baseKey - Key to use to get the base tax 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} pageNumber - Page ID for multi-page document
      */
-    constructor({ prediction, valueKey = "value", rateKey = "rate", codeKey = "code", baseKey = "base", reconstructed = false, pageId = undefined, }) {
+    constructor({ prediction = {}, valueKey = "value", rateKey = "rate", codeKey = "code", baseKey = "base", reconstructed = false, pageId = undefined, }) {
         super({ prediction, valueKey, reconstructed, pageId });
         _TaxField_instances.add(this);
         /** The tax amount. */
@@ -96,7 +96,7 @@ class Taxes extends Array {
         super(...arguments);
         _Taxes_instances.add(this);
     }
-    init(prediction, pageId) {
+    init(prediction = [], pageId) {
         for (const entry of prediction) {
             this.push(new TaxField({
                 prediction: entry,

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

@@ -1,4 +1,4 @@
-import { StringDict } from "./base";
+import { StringDict } from "../common";
 import { Field } from "./field";
 export interface FieldConstructor {
     prediction: StringDict;
@@ -9,7 +9,7 @@ export interface FieldConstructor {
 /**
  * A field containing a text value.
  */
-export declare class TextField extends Field {
+export declare class StringField extends Field {
     /** The value. */
     value?: string;
     constructor({ prediction, valueKey, reconstructed, pageId, }: FieldConstructor);

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

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TextField = void 0;
+exports.StringField = void 0;
 const field_1 = require("./field");
 /**
  * A field containing a text value.
  */
-class TextField extends field_1.Field {
-    constructor({ prediction, valueKey = "value", reconstructed = false, pageId, }) {
+class StringField extends field_1.Field {
+    constructor({ prediction = {}, valueKey = "value", reconstructed = false, pageId, }) {
         super({ prediction, valueKey, reconstructed, pageId });
     }
 }
-exports.TextField = TextField;
+exports.StringField = StringField;

package/src/parsing/standard/word.d.ts

@@ -0,0 +1,10 @@
+import * as geometry from "../../geometry";
+export type Word = {
+    /**
+     * Contains the relative vertices coordinates (points) of a polygon containing
+     * the field in the document.
+     */
+    polygon: geometry.Polygon;
+    text: string;
+    confidence: number;
+};

package/src/parsing/standard/word.js

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

package/src/pdf/pdfOperation.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { PageOptions } from "../inputs";
+import { PageOptions } from "../input";
 export interface SplitPdf {
     file: Buffer;
     totalPagesRemoved: number;

package/src/pdf/pdfOperation.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.countPages = exports.extractPages = void 0;
 const handler_1 = require("../errors/handler");
 const pdf_lib_1 = require("pdf-lib");
-const inputs_1 = require("../inputs");
+const input_1 = require("../input");
 const errors_1 = require("../errors");
 /**
  * Cut pages from a pdf file. If pages index are out of bound, it will throw an error.
@@ -37,13 +37,13 @@ async function extractPages(file, pageOptions) {
         don't exist in the file
         (${currentPdf.getPageIndices().join(", ")})`));
     }
-    if (pageOptions.operation === inputs_1.PageOptionsOperation.KeepOnly) {
+    if (pageOptions.operation === input_1.PageOptionsOperation.KeepOnly) {
         const keptPages = await newPdf.copyPages(currentPdf, pageIndexes);
         keptPages.forEach((keptPage) => {
             newPdf.addPage(keptPage);
         });
     }
-    else if (pageOptions.operation === inputs_1.PageOptionsOperation.Remove) {
+    else if (pageOptions.operation === input_1.PageOptionsOperation.Remove) {
         const pagesToKeep = currentPdf
             .getPageIndices()
             .filter((v) => !pageIndexes.includes(v));

package/src/product/cropper/cropperV1.d.ts

@@ -0,0 +1,9 @@
+import { Inference, Page, StringDict } from "../../parsing/common";
+import { CropperV1Document } from "./cropperV1Document";
+export declare class CropperV1 extends Inference {
+    endpointName: string;
+    endpointVersion: string;
+    prediction: CropperV1Document;
+    pages: Page<CropperV1Document>[];
+    constructor(rawPrediction: StringDict);
+}

package/src/product/cropper/cropperV1.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CropperV1 = void 0;
+const common_1 = require("../../parsing/common");
+const cropperV1Document_1 = require("./cropperV1Document");
+class CropperV1 extends common_1.Inference {
+    constructor(rawPrediction) {
+        super(rawPrediction);
+        this.endpointName = "cropper";
+        this.endpointVersion = "1";
+        this.pages = [];
+        this.prediction = new cropperV1Document_1.CropperV1Document(rawPrediction["prediction"]);
+        this.pages = rawPrediction["pages"].map((page) => new common_1.Page(cropperV1Document_1.CropperV1Document, page, page["id"], page["orientation"]));
+    }
+}
+exports.CropperV1 = CropperV1;

package/src/product/cropper/cropperV1Document.d.ts

@@ -0,0 +1,8 @@
+import { Prediction, StringDict } from "../../parsing/common";
+import { PositionField } from "../../parsing/standard";
+export declare class CropperV1Document implements Prediction {
+    /** A list of cropped positions. */
+    cropping: PositionField[];
+    constructor(rawPrediction: StringDict, pageId?: number);
+    toString(): string;
+}

package/src/product/cropper/cropperV1Document.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CropperV1Document = void 0;
+const summaryHelper_1 = require("../../parsing/common/summaryHelper");
+const standard_1 = require("../../parsing/standard");
+class CropperV1Document {
+    constructor(rawPrediction, pageId) {
+        /** A list of cropped positions. */
+        this.cropping = [];
+        rawPrediction["cropping"] &&
+            rawPrediction["cropping"].forEach((crop) => {
+                this.cropping.push(new standard_1.PositionField({
+                    prediction: crop,
+                    pageId: pageId,
+                }));
+            });
+    }
+    toString() {
+        const cropping = this.cropping
+            .map((crop) => crop.toString())
+            .join("\n           ");
+        const outStr = `:Cropping: ${cropping}`.trim();
+        return (0, summaryHelper_1.cleanOutString)(outStr);
+    }
+}
+exports.CropperV1Document = CropperV1Document;

package/src/product/custom/customV1.d.ts

@@ -0,0 +1,10 @@
+import { Inference, Page, StringDict } from "../../parsing/common";
+import { CustomV1Document } from "./customV1Document";
+import { CustomV1Page } from "./customV1Page";
+export declare class CustomV1 extends Inference {
+    endpointName: string;
+    endpointVersion: string;
+    prediction: CustomV1Document;
+    pages: Page<CustomV1Page>[];
+    constructor(rawPrediction: StringDict);
+}

package/src/product/custom/customV1.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomV1 = void 0;
+const common_1 = require("../../parsing/common");
+const customV1Document_1 = require("./customV1Document");
+const customV1Page_1 = require("./customV1Page");
+class CustomV1 extends common_1.Inference {
+    constructor(rawPrediction) {
+        super(rawPrediction);
+        this.endpointName = "custom";
+        this.endpointVersion = "1";
+        this.pages = [];
+        this.prediction = new customV1Document_1.CustomV1Document(rawPrediction["prediction"]);
+        this.pages = rawPrediction["pages"].map((page) => new common_1.Page(customV1Page_1.CustomV1Page, page, page["id"], page["orientation"]));
+    }
+}
+exports.CustomV1 = CustomV1;

package/src/product/custom/customV1Document.d.ts

@@ -0,0 +1,9 @@
+import { StringDict, Prediction } from "../../parsing/common";
+import { ClassificationField, ListField } from "../../parsing/custom";
+export declare class CustomV1Document implements Prediction {
+    fields: Map<string, ListField>;
+    classifications: Map<string, ClassificationField>;
+    constructor(rawPrediction: StringDict, pageId?: number);
+    protected setField(fieldName: string, fieldValue: any, pageId?: number): void;
+    toString(): string;
+}

package/src/product/custom/customV1Document.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomV1Document = void 0;
+const common_1 = require("../../parsing/common");
+const custom_1 = require("../../parsing/custom");
+class CustomV1Document {
+    constructor(rawPrediction, pageId) {
+        this.fields = new Map();
+        this.classifications = new Map();
+        Object.entries(rawPrediction).forEach(([fieldName, fieldValue]) => {
+            this.setField(fieldName, fieldValue, pageId);
+        });
+    }
+    setField(fieldName, fieldValue, pageId) {
+        // Currently, two types of fields possible in a custom API response:
+        // fields having a list of values, and classification fields.
+        if (fieldValue && fieldValue["values"] !== undefined) {
+            // Only value lists have the 'values' attribute.
+            this.fields.set(fieldName, new custom_1.ListField({
+                prediction: fieldValue,
+                pageId: pageId,
+            }));
+        }
+        else if (fieldValue && fieldValue["value"] !== undefined) {
+            // Only classifications have the 'value' attribute.
+            this.classifications.set(fieldName, new custom_1.ClassificationField({ prediction: fieldValue }));
+        }
+        else {
+            throw new Error(`Unknown API field type for field ${fieldName} : ${fieldValue}`);
+        }
+    }
+    toString() {
+        let outStr = "";
+        this.classifications.forEach((fieldData, name) => {
+            outStr += `:${name}: ${fieldData}\n`;
+        });
+        this.fields.forEach((fieldData, name) => {
+            outStr += `:${name}: ${fieldData}\n`;
+        });
+        return (0, common_1.cleanOutString)(outStr).trimEnd();
+    }
+}
+exports.CustomV1Document = CustomV1Document;

package/src/product/custom/customV1Page.d.ts

@@ -0,0 +1,7 @@
+import { StringDict, Prediction } from "../../parsing/common";
+import { ListField } from "../../parsing/custom";
+export declare class CustomV1Page implements Prediction {
+    fields: Map<string, ListField>;
+    constructor(rawPrediction: StringDict, pageId?: number);
+    toString(): string;
+}

package/src/product/custom/customV1Page.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomV1Page = void 0;
+const common_1 = require("../../parsing/common");
+const custom_1 = require("../../parsing/custom");
+class CustomV1Page {
+    constructor(rawPrediction, pageId) {
+        this.fields = new Map();
+        Object.entries(rawPrediction).forEach(([fieldName, fieldValue]) => {
+            this.fields.set(fieldName, new custom_1.ListField({
+                prediction: fieldValue,
+                pageId: pageId,
+            }));
+        });
+    }
+    toString() {
+        let outStr = "";
+        this.fields.forEach((fieldData, name) => {
+            outStr += `:${name}: ${fieldData}\n`;
+        });
+        return (0, common_1.cleanOutString)(outStr).trimEnd();
+    }
+}
+exports.CustomV1Page = CustomV1Page;