mindee 3.10.2 → 4.0.0

package/src/{inputs → input}/base.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputSource = exports.INPUT_TYPE_BUFFER = exports.INPUT_TYPE_URL = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
+exports.LocalInputSource = exports.InputSource = exports.INPUT_TYPE_BUFFER = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.INPUT_TYPE_STREAM = void 0;
 const fileType = __importStar(require("file-type"));
 const path = __importStar(require("path"));
 const pdf_1 = require("../pdf");
@@ -33,7 +33,6 @@ exports.INPUT_TYPE_STREAM = "stream";
 exports.INPUT_TYPE_BASE64 = "base64";
 exports.INPUT_TYPE_BYTES = "bytes";
 exports.INPUT_TYPE_PATH = "path";
-exports.INPUT_TYPE_URL = "URL";
 exports.INPUT_TYPE_BUFFER = "buffer";
 const MIMETYPES = new Map([
     [".pdf", "application/pdf"],
@@ -50,10 +49,15 @@ const ALLOWED_INPUT_TYPES = [
     exports.INPUT_TYPE_BASE64,
     exports.INPUT_TYPE_BYTES,
     exports.INPUT_TYPE_PATH,
-    exports.INPUT_TYPE_URL,
     exports.INPUT_TYPE_BUFFER,
 ];
 class InputSource {
+    async init() {
+        throw new Error("not Implemented");
+    }
+}
+exports.InputSource = InputSource;
+class LocalInputSource extends InputSource {
     /**
      * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
      *                             NB: dummy is only used for tests purposes
@@ -61,6 +65,7 @@ class InputSource {
      * NB: Because of async calls, init() should be called after creating the object
      */
     constructor({ inputType }) {
+        super();
         this.filename = "";
         this.mimeType = "";
         // Check if inputType is valid
@@ -71,9 +76,6 @@ class InputSource {
         this.inputType = inputType;
         logger_1.logger.debug(`Loading file from: ${inputType}`);
     }
-    async init() {
-        throw new Error("not Implemented");
-    }
     isPdf() {
         return this.mimeType === "application/pdf";
     }
@@ -115,4 +117,4 @@ class InputSource {
         this.fileObject = processedPdf.file;
     }
 }
-exports.InputSource = InputSource;
+exports.LocalInputSource = LocalInputSource;

package/src/{inputs → input}/index.d.ts

@@ -1,3 +1,3 @@
 export { PageOptions, PageOptionsOperation } from "./pageOptions";
 export { Base64Input, BytesInput, PathInput, StreamInput, UrlInput, BufferInput, } from "./sources";
-export { InputSource, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES, INPUT_TYPE_PATH, INPUT_TYPE_STREAM, INPUT_TYPE_URL, INPUT_TYPE_BUFFER, } from "./base";
+export { InputSource, INPUT_TYPE_BASE64, INPUT_TYPE_BYTES, INPUT_TYPE_PATH, INPUT_TYPE_STREAM, INPUT_TYPE_BUFFER, } from "./base";

package/src/{inputs → input}/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.INPUT_TYPE_BUFFER = exports.INPUT_TYPE_URL = exports.INPUT_TYPE_STREAM = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.InputSource = exports.BufferInput = exports.UrlInput = exports.StreamInput = exports.PathInput = exports.BytesInput = exports.Base64Input = exports.PageOptionsOperation = void 0;
+exports.INPUT_TYPE_BUFFER = exports.INPUT_TYPE_STREAM = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.InputSource = exports.BufferInput = exports.UrlInput = exports.StreamInput = exports.PathInput = exports.BytesInput = exports.Base64Input = exports.PageOptionsOperation = void 0;
 var pageOptions_1 = require("./pageOptions");
 Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return pageOptions_1.PageOptionsOperation; } });
 var sources_1 = require("./sources");
@@ -16,5 +16,4 @@ Object.defineProperty(exports, "INPUT_TYPE_BASE64", { enumerable: true, get: fun
 Object.defineProperty(exports, "INPUT_TYPE_BYTES", { enumerable: true, get: function () { return base_1.INPUT_TYPE_BYTES; } });
 Object.defineProperty(exports, "INPUT_TYPE_PATH", { enumerable: true, get: function () { return base_1.INPUT_TYPE_PATH; } });
 Object.defineProperty(exports, "INPUT_TYPE_STREAM", { enumerable: true, get: function () { return base_1.INPUT_TYPE_STREAM; } });
-Object.defineProperty(exports, "INPUT_TYPE_URL", { enumerable: true, get: function () { return base_1.INPUT_TYPE_URL; } });
 Object.defineProperty(exports, "INPUT_TYPE_BUFFER", { enumerable: true, get: function () { return base_1.INPUT_TYPE_BUFFER; } });

package/src/{inputs → input}/sources.d.ts

@@ -2,11 +2,11 @@
 /// <reference types="node" />
 import { Readable } from "stream";
 import { Buffer } from "buffer";
-import { InputSource } from "./base";
+import { LocalInputSource } from "./base";
 interface PathInputProps {
     inputPath: string;
 }
-export declare class PathInput extends InputSource {
+export declare class PathInput extends LocalInputSource {
     readonly inputPath: string;
     fileObject: Buffer;
     constructor({ inputPath }: PathInputProps);
@@ -16,7 +16,7 @@ interface Base64InputProps {
     inputString: string;
     filename: string;
 }
-export declare class Base64Input extends InputSource {
+export declare class Base64Input extends LocalInputSource {
     private inputString;
     fileObject: Buffer;
     constructor({ inputString, filename }: Base64InputProps);
@@ -26,7 +26,7 @@ interface StreamInputProps {
     inputStream: Readable;
     filename: string;
 }
-export declare class StreamInput extends InputSource {
+export declare class StreamInput extends LocalInputSource {
     private readonly inputStream;
     fileObject: Buffer;
     constructor({ inputStream, filename }: StreamInputProps);
@@ -37,26 +37,25 @@ interface BytesInputProps {
     inputBytes: string;
     filename: string;
 }
-export declare class BytesInput extends InputSource {
+export declare class BytesInput extends LocalInputSource {
     private inputBytes;
     fileObject: Buffer;
     constructor({ inputBytes, filename }: BytesInputProps);
     init(): Promise<void>;
 }
-interface UrlInputProps {
-    url: string;
-}
-export declare class UrlInput extends InputSource {
+export declare class UrlInput {
     private readonly url;
     fileObject: string;
-    constructor({ url }: UrlInputProps);
+    constructor({ url }: {
+        url: string;
+    });
     init(): Promise<void>;
 }
 interface BufferInputProps {
     buffer: Buffer;
     filename: string;
 }
-export declare class BufferInput extends InputSource {
+export declare class BufferInput extends LocalInputSource {
     constructor({ buffer, filename }: BufferInputProps);
     init(): Promise<void>;
 }

package/src/{inputs → input}/sources.js

@@ -30,7 +30,7 @@ const handler_1 = require("../errors/handler");
 const buffer_1 = require("buffer");
 const logger_1 = require("../logger");
 const base_1 = require("./base");
-class PathInput extends base_1.InputSource {
+class PathInput extends base_1.LocalInputSource {
     constructor({ inputPath }) {
         super({
             inputType: base_1.INPUT_TYPE_PATH,
@@ -46,7 +46,7 @@ class PathInput extends base_1.InputSource {
     }
 }
 exports.PathInput = PathInput;
-class Base64Input extends base_1.InputSource {
+class Base64Input extends base_1.LocalInputSource {
     constructor({ inputString, filename }) {
         super({
             inputType: base_1.INPUT_TYPE_BASE64,
@@ -63,7 +63,7 @@ class Base64Input extends base_1.InputSource {
     }
 }
 exports.Base64Input = Base64Input;
-class StreamInput extends base_1.InputSource {
+class StreamInput extends base_1.LocalInputSource {
     constructor({ inputStream, filename }) {
         super({
             inputType: base_1.INPUT_TYPE_STREAM,
@@ -86,7 +86,7 @@ class StreamInput extends base_1.InputSource {
     }
 }
 exports.StreamInput = StreamInput;
-class BytesInput extends base_1.InputSource {
+class BytesInput extends base_1.LocalInputSource {
     constructor({ inputBytes, filename }) {
         super({
             inputType: base_1.INPUT_TYPE_BYTES,
@@ -103,11 +103,11 @@ class BytesInput extends base_1.InputSource {
     }
 }
 exports.BytesInput = BytesInput;
-class UrlInput extends base_1.InputSource {
+//
+// URL
+//
+class UrlInput {
     constructor({ url }) {
-        super({
-            inputType: base_1.INPUT_TYPE_URL,
-        });
         this.url = url;
     }
     async init() {
@@ -118,7 +118,7 @@ class UrlInput extends base_1.InputSource {
     }
 }
 exports.UrlInput = UrlInput;
-class BufferInput extends base_1.InputSource {
+class BufferInput extends base_1.LocalInputSource {
     constructor({ buffer, filename }) {
         super({
             inputType: base_1.INPUT_TYPE_BUFFER,

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

@@ -0,0 +1,10 @@
+import { StringDict } from "./stringDict";
+export declare class ApiRequest {
+    error: StringDict;
+    resources: string[];
+    status: "failure" | "success";
+    /** HTTP status code */
+    statusCode: number;
+    url: string;
+    constructor(serverResponse: StringDict);
+}

package/src/parsing/common/apiRequest.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiRequest = void 0;
+class ApiRequest {
+    constructor(serverResponse) {
+        this.error = serverResponse["error"];
+        this.resources = serverResponse["resources"];
+        this.status = serverResponse["status"];
+        this.statusCode = serverResponse["status_code"];
+        this.url = serverResponse["url"];
+    }
+}
+exports.ApiRequest = ApiRequest;

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

@@ -0,0 +1,6 @@
+import { ApiRequest } from "./apiRequest";
+import { StringDict } from "./stringDict";
+export declare abstract class ApiResponse {
+    apiRequest: ApiRequest;
+    constructor(serverResponse: StringDict);
+}

package/src/parsing/common/apiResponse.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiResponse = void 0;
+const apiRequest_1 = require("./apiRequest");
+class ApiResponse {
+    constructor(serverResponse) {
+        this.apiRequest = new apiRequest_1.ApiRequest(serverResponse["api_request"]);
+    }
+}
+exports.ApiResponse = ApiResponse;

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

@@ -0,0 +1,21 @@
+import { ApiResponse } from "./apiResponse";
+import { StringDict } from "./stringDict";
+import { Inference } from "./inference";
+import { Document } from "./document";
+export declare class Job {
+    issuedAt: Date;
+    availableAt?: Date;
+    id: string;
+    status?: "waiting" | "processing" | "completed";
+    /**
+     * The time taken to process the job, in milliseconds.
+     */
+    milliSecsTaken?: number;
+    constructor(jsonResponse: StringDict);
+    protected datetimeWithTimezone(date: string): Date;
+}
+export declare class AsyncPredictResponse<T extends Inference> extends ApiResponse {
+    job: Job;
+    document?: Document<T>;
+    constructor(inferenceClass: new (httpResponse: StringDict) => T, httpResponse: StringDict);
+}

package/src/parsing/common/asyncPredictResponse.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncPredictResponse = exports.Job = void 0;
+const apiResponse_1 = require("./apiResponse");
+const document_1 = require("./document");
+class Job {
+    constructor(jsonResponse) {
+        this.issuedAt = this.datetimeWithTimezone(jsonResponse["issued_at"]);
+        if (jsonResponse["available_at"] !== undefined &&
+            jsonResponse["available_at"] !== null) {
+            this.availableAt = this.datetimeWithTimezone(jsonResponse["available_at"]);
+        }
+        this.id = jsonResponse["id"];
+        this.status = jsonResponse["status"];
+        if (this.availableAt !== undefined) {
+            this.milliSecsTaken =
+                this.availableAt.getTime() - this.issuedAt.getTime();
+        }
+    }
+    // Hideous thing to make sure dates sent back by the server are parsed correctly in UTC.
+    datetimeWithTimezone(date) {
+        if (date.search(/\+[0-9]{2}:[0-9]{2}$/) === -1) {
+            date += "+00:00";
+        }
+        return new Date(date);
+    }
+}
+exports.Job = Job;
+class AsyncPredictResponse extends apiResponse_1.ApiResponse {
+    constructor(inferenceClass, httpResponse) {
+        super(httpResponse);
+        this.job = new Job(httpResponse["job"]);
+        this.document =
+            httpResponse["document"] !== undefined
+                ? new document_1.Document(inferenceClass, httpResponse["document"])
+                : undefined;
+    }
+}
+exports.AsyncPredictResponse = AsyncPredictResponse;

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

@@ -0,0 +1,13 @@
+import { Extras } from "./extras/extras";
+import { Inference } from "./inference";
+import { Ocr } from "./ocr";
+import { StringDict } from "./stringDict";
+export declare class Document<T extends Inference> {
+    filename: string;
+    inference: T;
+    id: string;
+    extras?: Extras;
+    ocr?: Ocr;
+    constructor(inferenceClass: new (httpResponse: StringDict) => T, httpResponse: StringDict);
+    toString(): string;
+}

package/src/parsing/common/document.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Document = void 0;
+const cropperExtra_1 = require("./extras/cropperExtra");
+const extras_1 = require("./extras/extras");
+class Document {
+    constructor(inferenceClass, httpResponse) {
+        this.id = httpResponse["id"] ?? "";
+        this.filename = httpResponse["name"] ?? "";
+        this.ocr = httpResponse["ocr"] ?? undefined;
+        this.inference = new inferenceClass(httpResponse["inference"]);
+        // Note: this is a convoluted but functional way of being able to implement/use Extras fields
+        // as an extension of a Map object (like having an adapted toString() method, for instance)
+        if (httpResponse["extras"] &&
+            Object.keys(httpResponse["extras"].length > 0)) {
+            const extras = {};
+            Object.entries(httpResponse["extras"]).forEach(([extraKey, extraValue]) => {
+                switch (extraKey) {
+                    case "cropper":
+                        extras["cropper"] = new cropperExtra_1.CropperExtra(extraValue);
+                }
+            });
+            this.extras = new extras_1.Extras(extras);
+        }
+    }
+    toString() {
+        return `########\nDocument\n########
+:Mindee ID: ${this.id}
+:Filename: ${this.filename}
+
+${this.inference?.toString()}`;
+    }
+}
+exports.Document = Document;

package/src/parsing/common/extras/cropperExtra.d.ts

@@ -0,0 +1,8 @@
+import { PositionField } from "../../standard";
+import { StringDict } from "../stringDict";
+import { ExtraField } from "./extras";
+export declare class CropperExtra extends ExtraField {
+    cropping: PositionField[];
+    constructor(rawPrediction: StringDict, pageId?: number);
+    toString(): string;
+}

package/src/parsing/common/extras/cropperExtra.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CropperExtra = void 0;
+const standard_1 = require("../../standard");
+const summaryHelper_1 = require("../summaryHelper");
+const extras_1 = require("./extras");
+class CropperExtra extends extras_1.ExtraField {
+    constructor(rawPrediction, pageId) {
+        super();
+        this.cropping = [];
+        rawPrediction["cropping"] !== undefined &&
+            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          ");
+        return (0, summaryHelper_1.cleanOutString)(cropping);
+    }
+}
+exports.CropperExtra = CropperExtra;

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

@@ -0,0 +1,11 @@
+export declare abstract class ExtraField {
+}
+interface ExtraDict<T extends ExtraField> {
+    [key: string]: T | (() => string);
+}
+export declare class Extras<ExtraT extends ExtraField = ExtraField> implements ExtraDict<ExtraT> {
+    [key: string]: ExtraT | (() => string);
+    constructor(fields: Record<string, ExtraT>);
+    toString(): string;
+}
+export {};

package/src/parsing/common/extras/extras.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extras = exports.ExtraField = void 0;
+class ExtraField {
+}
+exports.ExtraField = ExtraField;
+class Extras {
+    constructor(fields) {
+        Object.keys(fields).length > 0 &&
+            Object.keys(fields).forEach((name) => (this[name] = fields[name]));
+    }
+    toString() {
+        return (Object.entries(this)
+            .map(([name, extraField]) => name + ":\n" + extraField.toString())
+            .join("\n") + "\n");
+    }
+}
+exports.Extras = Extras;

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

@@ -0,0 +1,9 @@
+export { Document } from "./document";
+export { OrientationField } from "./orientation";
+export { StringDict } from "./stringDict";
+export { Inference } from "./inference";
+export { AsyncPredictResponse } from "./asyncPredictResponse";
+export { PredictResponse } from "./predictResponse";
+export { Prediction } from "./prediction";
+export { Page } from "./page";
+export { cleanOutString, lineSeparator } from "./summaryHelper";

package/src/parsing/common/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineSeparator = exports.cleanOutString = exports.Page = exports.Prediction = exports.PredictResponse = exports.AsyncPredictResponse = exports.Inference = exports.OrientationField = exports.Document = void 0;
+var document_1 = require("./document");
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return document_1.Document; } });
+var orientation_1 = require("./orientation");
+Object.defineProperty(exports, "OrientationField", { enumerable: true, get: function () { return orientation_1.OrientationField; } });
+var inference_1 = require("./inference");
+Object.defineProperty(exports, "Inference", { enumerable: true, get: function () { return inference_1.Inference; } });
+var asyncPredictResponse_1 = require("./asyncPredictResponse");
+Object.defineProperty(exports, "AsyncPredictResponse", { enumerable: true, get: function () { return asyncPredictResponse_1.AsyncPredictResponse; } });
+var predictResponse_1 = require("./predictResponse");
+Object.defineProperty(exports, "PredictResponse", { enumerable: true, get: function () { return predictResponse_1.PredictResponse; } });
+var prediction_1 = require("./prediction");
+Object.defineProperty(exports, "Prediction", { enumerable: true, get: function () { return prediction_1.Prediction; } });
+var page_1 = require("./page");
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return page_1.Page; } });
+var summaryHelper_1 = require("./summaryHelper");
+Object.defineProperty(exports, "cleanOutString", { enumerable: true, get: function () { return summaryHelper_1.cleanOutString; } });
+Object.defineProperty(exports, "lineSeparator", { enumerable: true, get: function () { return summaryHelper_1.lineSeparator; } });

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

@@ -0,0 +1,26 @@
+import { StringDict } from "../common";
+import { ExtraField } from "./extras/extras";
+import { Page } from "./page";
+import type { Prediction } from "./prediction";
+import { Product } from "./product";
+export declare abstract class Inference<DocT extends Prediction = Prediction, PageT extends DocT = DocT> {
+    isRotationApplied?: boolean;
+    product: Product;
+    pages: Page<PageT>[];
+    prediction: DocT;
+    extras?: ExtraField[];
+    endpointName?: string;
+    endpointVersion?: string;
+    constructor(rawPrediction: StringDict);
+    toString(): string;
+    static cleanOutString(outStr: string): string;
+}
+export declare class InferenceFactory {
+    /**
+     * Builds a blank product of the given type & sends back the endpointName & endpointVersion parameters of OTS classes.
+     * Note: this is needed to avoid passing anything other than the class of the object to the parse()/enqueue() call.
+     * @param inferenceClass Class of the product we are using
+     * @returns {Inference} An empty instance of a given product.
+     */
+    static getEndpoint<T extends Inference>(inferenceClass: new (httpResponse: StringDict) => T): [string, string];
+}

package/src/parsing/common/inference.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InferenceFactory = exports.Inference = void 0;
+class Inference {
+    constructor(rawPrediction) {
+        this.pages = [];
+        this.extras = [];
+        this.isRotationApplied = rawPrediction["is_rotation_applied"] ?? undefined;
+        this.product = rawPrediction["product"];
+    }
+    toString() {
+        return `Inference
+#########
+:Product: ${this.product.name} v${this.product.version}
+:Rotation applied: ${this.isRotationApplied ? "Yes" : "No"}
+
+Prediction
+==========
+${this.prediction.toString() || ""}
+
+Page Predictions
+================
+
+${this.pages.map((e) => e.toString() || "").join("\n")}`;
+    }
+    static cleanOutString(outStr) {
+        const lines = / \n/gm;
+        return outStr.replace(lines, "\n");
+    }
+}
+exports.Inference = Inference;
+class InferenceFactory {
+    /**
+     * Builds a blank product of the given type & sends back the endpointName & endpointVersion parameters of OTS classes.
+     * Note: this is needed to avoid passing anything other than the class of the object to the parse()/enqueue() call.
+     * @param inferenceClass Class of the product we are using
+     * @returns {Inference} An empty instance of a given product.
+     */
+    static getEndpoint(inferenceClass) {
+        if (inferenceClass.name === "CustomV1") {
+            throw new Error("Cannot process custom endpoint as OTS API endpoints. Please provide an endpoint name & version manually.");
+        }
+        const emptyProduct = new inferenceClass({
+            prediction: {},
+            pages: [],
+        });
+        if (!emptyProduct.endpointName ||
+            !emptyProduct.endpointVersion ||
+            emptyProduct.endpointName.length === 0 ||
+            emptyProduct.endpointVersion.length === 0) {
+            throw new Error(`Error during endpoint verification, no endpoint found for product ${inferenceClass.name}.`);
+        }
+        return [emptyProduct.endpointName, emptyProduct.endpointVersion];
+    }
+}
+exports.InferenceFactory = InferenceFactory;

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

@@ -0,0 +1,8 @@
+import { StringDict } from "./stringDict";
+import { OcrPage } from "./ocrPage";
+export declare class MvisionV1 {
+    /** List of words found on the page. */
+    pages: OcrPage[];
+    constructor(rawPrediction: StringDict);
+    toString(): string;
+}

package/src/parsing/common/mvisionV1.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MvisionV1 = void 0;
+const ocrPage_1 = require("./ocrPage");
+class MvisionV1 {
+    constructor(rawPrediction) {
+        /** List of words found on the page. */
+        this.pages = [];
+        rawPrediction["pages"].map((page) => {
+            this.pages.push(new ocrPage_1.OcrPage(page));
+        });
+    }
+    toString() {
+        return this.pages.map((page) => page.toString()).join("\n") + "\n";
+    }
+}
+exports.MvisionV1 = MvisionV1;

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

@@ -0,0 +1,8 @@
+import { StringDict } from "./stringDict";
+import { MvisionV1 } from "./mvisionV1";
+export declare class Ocr {
+    /** Default Mindee OCR */
+    mVisionV1: MvisionV1;
+    constructor(rawPrediction: StringDict);
+    toString(): string;
+}

package/src/parsing/common/ocr.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ocr = void 0;
+const mvisionV1_1 = require("./mvisionV1");
+class Ocr {
+    constructor(rawPrediction) {
+        this.mVisionV1 = new mvisionV1_1.MvisionV1(rawPrediction["mvision-v1"]);
+    }
+    toString() {
+        return this.mVisionV1.toString();
+    }
+}
+exports.Ocr = Ocr;

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

@@ -0,0 +1,16 @@
+import { Word } from "../standard";
+import { StringDict } from "./stringDict";
+export declare class OcrPage {
+    #private;
+    /** Flat list of all words read */
+    allWords: Word[];
+    /** List of words by which line they are on */
+    allLines: Word[][];
+    constructor(rawPrediction: StringDict);
+    /**
+     * Get all words on the page as ordered lines
+     * @returns Sorted lines on the pages
+     */
+    getAllLines(): Word[][];
+    toString(): string;
+}