mindee 1.4.0 → 2.0.1

package/src/api/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.CustomEndpoint = exports.PassportEndpoint = exports.ReceiptEndpoint = exports.InvoiceEndpoint = exports.Endpoint = exports.CustomResponse = exports.PassportResponse = exports.FinancialDocResponse = exports.ReceiptResponse = exports.InvoiceResponse = exports.Response = void 0;
+var response_1 = require("./response");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return response_1.Response; } });
+Object.defineProperty(exports, "InvoiceResponse", { enumerable: true, get: function () { return response_1.InvoiceResponse; } });
+Object.defineProperty(exports, "ReceiptResponse", { enumerable: true, get: function () { return response_1.ReceiptResponse; } });
+Object.defineProperty(exports, "FinancialDocResponse", { enumerable: true, get: function () { return response_1.FinancialDocResponse; } });
+Object.defineProperty(exports, "PassportResponse", { enumerable: true, get: function () { return response_1.PassportResponse; } });
+Object.defineProperty(exports, "CustomResponse", { enumerable: true, get: function () { return response_1.CustomResponse; } });
+var endpoint_1 = require("./endpoint");
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
+Object.defineProperty(exports, "InvoiceEndpoint", { enumerable: true, get: function () { return endpoint_1.InvoiceEndpoint; } });
+Object.defineProperty(exports, "ReceiptEndpoint", { enumerable: true, get: function () { return endpoint_1.ReceiptEndpoint; } });
+Object.defineProperty(exports, "PassportEndpoint", { enumerable: true, get: function () { return endpoint_1.PassportEndpoint; } });
+Object.defineProperty(exports, "CustomEndpoint", { enumerable: true, get: function () { return endpoint_1.CustomEndpoint; } });
+Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return endpoint_1.STANDARD_API_OWNER; } });
+Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return endpoint_1.API_KEY_ENVVAR_NAME; } });

package/src/api/response.d.ts

@@ -0,0 +1,52 @@
+import { Document, Passport, Receipt, Invoice, FinancialDocument, CustomDocument, DocumentConstructorProps } from "../documents";
+import { FullText } from "../fields";
+import { Input } from "../inputs";
+export interface ResponseProps {
+    httpResponse: any;
+    documentType: string;
+    input: Input;
+    error: boolean;
+}
+/**
+ * Base class for all responses.
+ */
+export declare class Response<DocType extends Document> {
+    httpResponse: any;
+    readonly documentType: string;
+    inputFile: Input;
+    document?: DocType;
+    pages: Array<DocType>;
+    constructor(params: ResponseProps);
+    protected getPageText(httpDataDocument: any, pageId: number): FullText;
+}
+/**
+ * Class for all constructed (API Builder) endpoint responses.
+ */
+export declare class CustomResponse extends Response<CustomDocument> {
+    constructor(params: ResponseProps);
+    protected formatResponse(): void;
+}
+declare type StandardDocumentSig<DocType extends Document> = {
+    new ({ apiPrediction, inputFile, pageId, fullText, }: DocumentConstructorProps): DocType;
+};
+/**
+ * Generic class for all standard (Off-the-Shelf) endpoint responses.
+ */
+export declare class StandardProductResponse<DocType extends Document> extends Response<DocType> {
+    documentClass: StandardDocumentSig<DocType>;
+    constructor(documentClass: StandardDocumentSig<DocType>, params: ResponseProps);
+    protected formatResponse(): void;
+}
+export declare class InvoiceResponse extends StandardProductResponse<Invoice> {
+    constructor(params: ResponseProps);
+}
+export declare class ReceiptResponse extends StandardProductResponse<Receipt> {
+    constructor(params: ResponseProps);
+}
+export declare class FinancialDocResponse extends StandardProductResponse<FinancialDocument> {
+    constructor(params: ResponseProps);
+}
+export declare class PassportResponse extends StandardProductResponse<Passport> {
+    constructor(params: ResponseProps);
+}
+export {};

package/src/api/response.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PassportResponse = exports.FinancialDocResponse = exports.ReceiptResponse = exports.InvoiceResponse = exports.StandardProductResponse = exports.CustomResponse = exports.Response = void 0;
+const documents_1 = require("../documents");
+const fields_1 = require("../fields");
+/**
+ * Base class for all responses.
+ */
+class Response {
+    constructor(params) {
+        this.pages = [];
+        this.httpResponse = params.httpResponse;
+        this.documentType = params.documentType;
+        this.inputFile = params.input;
+    }
+    getPageText(httpDataDocument, pageId) {
+        const pageText = new fields_1.FullText();
+        if ("ocr" in httpDataDocument &&
+            Object.keys(httpDataDocument.ocr).length > 0) {
+            pageText.words =
+                httpDataDocument.ocr["mvision-v1"].pages[pageId].all_words;
+        }
+        return pageText;
+    }
+}
+exports.Response = Response;
+/**
+ * Class for all constructed (API Builder) endpoint responses.
+ */
+class CustomResponse extends Response {
+    constructor(params) {
+        super(params);
+        if (!params.error) {
+            this.formatResponse();
+        }
+    }
+    formatResponse() {
+        const httpDataDocument = this.httpResponse.data.document;
+        httpDataDocument.inference.pages.forEach((apiPage) => {
+            this.pages.push(new documents_1.CustomDocument({
+                apiPrediction: apiPage.prediction,
+                inputFile: this.inputFile,
+                pageId: apiPage.id,
+                documentType: this.documentType,
+            }));
+        });
+        this.document = new documents_1.CustomDocument({
+            apiPrediction: httpDataDocument.inference.prediction,
+            inputFile: this.inputFile,
+            documentType: this.documentType,
+        });
+    }
+}
+exports.CustomResponse = CustomResponse;
+/**
+ * Generic class for all standard (Off-the-Shelf) endpoint responses.
+ */
+class StandardProductResponse extends Response {
+    constructor(documentClass, params) {
+        super(params);
+        this.documentClass = documentClass;
+        if (!params.error) {
+            this.formatResponse();
+        }
+    }
+    formatResponse() {
+        const httpDataDocument = this.httpResponse.data.document;
+        httpDataDocument.inference.pages.forEach((apiPage) => {
+            const pageText = this.getPageText(httpDataDocument, apiPage.id);
+            this.pages.push(new this.documentClass({
+                apiPrediction: apiPage.prediction,
+                inputFile: this.inputFile,
+                pageId: apiPage.id,
+                fullText: pageText,
+            }));
+        });
+        this.document = new this.documentClass({
+            apiPrediction: httpDataDocument.inference.prediction,
+            inputFile: this.inputFile,
+        });
+    }
+}
+exports.StandardProductResponse = StandardProductResponse;
+class InvoiceResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Invoice, params);
+    }
+}
+exports.InvoiceResponse = InvoiceResponse;
+class ReceiptResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Receipt, params);
+    }
+}
+exports.ReceiptResponse = ReceiptResponse;
+class FinancialDocResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.FinancialDocument, params);
+    }
+}
+exports.FinancialDocResponse = FinancialDocResponse;
+class PassportResponse extends StandardProductResponse {
+    constructor(params) {
+        super(documents_1.Passport, params);
+    }
+}
+exports.PassportResponse = PassportResponse;

package/src/cli.d.ts

@@ -0,0 +1 @@
+export declare function cli(): void;

package/src/cli.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = void 0;
+const commander_1 = require("commander");
+const documents_1 = require("./documents");
+const api_1 = require("./api");
+const client_1 = require("./client");
+const constants_1 = require("./constants");
+const program = new commander_1.Command();
+const COMMAND_INVOICE = "invoice";
+const COMMAND_RECEIPT = "receipt";
+const COMMAND_PASSPORT = "passport";
+const COMMAND_FINANCIAL = "financial";
+const COMMAND_CUSTOM = "custom";
+const CLI_COMMAND_CONFIG = new Map([
+    [COMMAND_INVOICE, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_INVOICE)],
+    [COMMAND_RECEIPT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_RECEIPT)],
+    [COMMAND_PASSPORT, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_PASSPORT)],
+    [COMMAND_FINANCIAL, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_FINANCIAL)],
+    [COMMAND_CUSTOM, constants_1.ProductConfigs.getByDocType(documents_1.DOC_TYPE_CUSTOM)],
+]);
+async function predictCall(command, inputPath, options) {
+    const conf = CLI_COMMAND_CONFIG.get(command);
+    if (conf === undefined) {
+        throw new Error(`Invalid document type ${command}`);
+    }
+    const mindeeClient = new client_1.Client({
+        apiKey: options.apiKey,
+        debug: options.debug,
+    });
+    if (command === COMMAND_CUSTOM) {
+        mindeeClient.addEndpoint({
+            accountName: options.user,
+            documentType: options.documentType,
+        });
+    }
+    const doc = mindeeClient.docFromPath(inputPath);
+    const params = {
+        docType: command === COMMAND_CUSTOM ? options.documentType : conf.docType,
+        username: command === COMMAND_CUSTOM ? options.user : api_1.STANDARD_API_OWNER,
+        cutPages: options.cutPages,
+        fullText: options.fullText,
+    };
+    // Tried setting the response by using the responseClass property in constants.PRODUCTS_CONFIG
+    // This compiled, but threw an exception:
+    //   TypeError: responseType is not a constructor
+    //
+    // So using a switch to explicitly set the response class parameter. Ugly, but works.
+    // Improvements welcome!
+    let response;
+    switch (command) {
+        case COMMAND_INVOICE:
+            response = await doc.parse(api_1.InvoiceResponse, params);
+            break;
+        case COMMAND_RECEIPT:
+            response = await doc.parse(api_1.ReceiptResponse, params);
+            break;
+        case COMMAND_FINANCIAL:
+            response = await doc.parse(api_1.FinancialDocResponse, params);
+            break;
+        case COMMAND_PASSPORT:
+            response = await doc.parse(api_1.PassportResponse, params);
+            break;
+        case COMMAND_CUSTOM:
+            response = await doc.parse(api_1.CustomResponse, params);
+            break;
+        default:
+            throw `Unhandled command: ${command}`;
+    }
+    if (response.document) {
+        console.log(`\n${response.document}`);
+    }
+}
+function cli() {
+    program.name("mindee");
+    program.option("-d, --debug", "high verbosity mode");
+    CLI_COMMAND_CONFIG.forEach((info, name) => {
+        const prog = program.command(name);
+        prog.description(info.description);
+        prog.option("-k, --api-key <api_key>", "API key for document endpoint");
+        prog.option("-C, --no-cut-pages", "Don't cut document pages");
+        if (info.fullText) {
+            prog.option("-t, --full-text", "Include full document text in response");
+        }
+        if (name === COMMAND_CUSTOM) {
+            prog.requiredOption("-u, --user <username>", "API account name for the endpoint");
+            prog.option("-v, --version <version>", "API account name for the endpoint");
+            prog.argument("<endpoint_name>", "API endpoint name");
+        }
+        prog.argument("<input_path>", "Full path to the file");
+        if (name === COMMAND_CUSTOM) {
+            prog.action((endpointName, inputPath, options, command) => {
+                const allOptions = {
+                    ...program.opts(),
+                    ...options,
+                    documentType: endpointName,
+                };
+                predictCall(command.name(), inputPath, allOptions);
+            });
+        }
+        else {
+            prog.action((inputPath, options, command) => {
+                const allOptions = {
+                    ...program.opts(),
+                    ...options,
+                    endpointName: undefined,
+                };
+                predictCall(command.name(), inputPath, allOptions);
+            });
+        }
+    });
+    program.parse(process.argv);
+}
+exports.cli = cli;

package/src/client.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="node" />
+import { Input } from "./inputs";
+import { Response } from "./api";
+import { Document } from "./documents";
+import { DocumentConfig, responseSig } from "./documents/documentConfig";
+import { ReadStream } from "fs";
+declare type DocConfigs = Map<string[], DocumentConfig>;
+interface PredictOptions {
+    docType?: string;
+    username?: string;
+    cutPages?: boolean;
+    fullText?: boolean;
+}
+declare class DocumentClient {
+    inputDoc: Input;
+    docConfigs: DocConfigs;
+    constructor(inputDoc: Input, docConfigs: DocConfigs);
+    parse<RespType extends Response<Document>>(responseClass: responseSig<RespType>, params?: PredictOptions): Promise<RespType>;
+    protected getDocType(responseClass: string): string;
+}
+interface customConfigParams {
+    accountName: string;
+    documentType: string;
+    version?: string;
+}
+interface ClientOptions {
+    apiKey?: string;
+    throwOnError?: boolean;
+    debug?: boolean;
+}
+/**
+ * Mindee Client
+ */
+export declare class Client {
+    readonly docConfigs: DocConfigs;
+    protected apiKey: string;
+    /**
+     * @param options
+     */
+    constructor(options?: ClientOptions);
+    protected addStandardEndpoints(): void;
+    addEndpoint({ accountName, documentType, version, }: customConfigParams): this;
+    docFromPath(inputPath: string): DocumentClient;
+    docFromBase64(inputString: string, filename: string): DocumentClient;
+    docFromStream(inputStream: ReadStream, filename: string): DocumentClient;
+    docFromBytes(inputBytes: string, filename: string): DocumentClient;
+}
+export {};

package/src/client.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const inputs_1 = require("./inputs");
+const api_1 = require("./api");
+const documents_1 = require("./documents");
+const documentConfig_1 = require("./documents/documentConfig");
+const handler_1 = require("./errors/handler");
+const logger_1 = require("./logger");
+const constants_1 = require("./constants");
+class DocumentClient {
+    constructor(inputDoc, docConfigs) {
+        this.inputDoc = inputDoc;
+        this.docConfigs = docConfigs;
+    }
+    async parse(responseClass, params = {
+        docType: "",
+        username: "",
+        cutPages: true,
+        fullText: false,
+    }) {
+        // seems like there should be a better way of doing this
+        const fullText = params?.fullText !== undefined ? params.fullText : false;
+        const cutPages = params?.cutPages !== undefined ? params.cutPages : true;
+        const docType = params.docType === undefined || params.docType === ""
+            ? this.getDocType(responseClass.name)
+            : params.docType;
+        const found = [];
+        this.docConfigs.forEach((config, configKey) => {
+            if (configKey[1] === docType) {
+                found.push(configKey);
+            }
+        });
+        if (found.length === 0) {
+            throw `Document type not configured: '${docType}'`;
+        }
+        let configKey = [];
+        if (found.length === 1) {
+            configKey = found[0];
+        }
+        else if (params.username) {
+            configKey = [params.username, docType];
+        }
+        const docConfig = this.docConfigs.get(configKey);
+        if (docConfig === undefined) {
+            // TODO: raise error printing all usernames
+            throw `Couldn't find the config '${configKey}'`;
+        }
+        return await docConfig.predict(responseClass, {
+            inputDoc: this.inputDoc,
+            includeWords: fullText,
+            cutPages: cutPages,
+        });
+    }
+    getDocType(responseClass) {
+        return constants_1.ProductConfigs.getByResponseClassName(responseClass).docType;
+    }
+}
+/**
+ * Mindee Client
+ */
+class Client {
+    /**
+     * @param options
+     */
+    constructor(options) {
+        const throwOnError = options?.throwOnError === undefined ? true : options.throwOnError;
+        const debug = options?.debug === undefined ? false : options.debug;
+        this.apiKey = options?.apiKey === undefined ? "" : options.apiKey;
+        this.docConfigs = new Map();
+        handler_1.errorHandler.throwOnError = throwOnError;
+        logger_1.logger.level =
+            debug ?? process.env.MINDEE_DEBUG
+                ? logger_1.LOG_LEVELS["debug"]
+                : logger_1.LOG_LEVELS["warn"];
+        logger_1.logger.debug("Client initialized");
+        this.addStandardEndpoints();
+    }
+    // TODO: init only those endpoints we actually need.
+    addStandardEndpoints() {
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_INVOICE], new documentConfig_1.InvoiceConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_RECEIPT], new documentConfig_1.ReceiptConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_FINANCIAL], new documentConfig_1.FinancialDocConfig(this.apiKey));
+        this.docConfigs.set([api_1.STANDARD_API_OWNER, documents_1.DOC_TYPE_PASSPORT], new documentConfig_1.PassportConfig(this.apiKey));
+    }
+    addEndpoint({ accountName, documentType, version = "1", }) {
+        this.docConfigs.set([accountName, documentType], new documentConfig_1.CustomDocConfig({
+            accountName: accountName,
+            documentType: documentType,
+            version: version,
+            apiKey: this.apiKey,
+        }));
+        return this;
+    }
+    docFromPath(inputPath) {
+        const doc = new inputs_1.PathInput({
+            inputPath: inputPath,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromBase64(inputString, filename) {
+        const doc = new inputs_1.Base64Input({
+            inputString: inputString,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromStream(inputStream, filename) {
+        const doc = new inputs_1.StreamInput({
+            inputStream: inputStream,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+    docFromBytes(inputBytes, filename) {
+        const doc = new inputs_1.BytesInput({
+            inputBytes: inputBytes,
+            filename: filename,
+        });
+        return new DocumentClient(doc, this.docConfigs);
+    }
+}
+exports.Client = Client;

package/src/constants.d.ts

@@ -0,0 +1,13 @@
+import { Response } from "./api";
+import { Document } from "./documents";
+export interface ProductConfig {
+    description: string;
+    docType: string;
+    responseClass: typeof Response<Document>;
+    fullText: boolean;
+}
+export declare class ProductConfigs {
+    private static configs;
+    static getByResponseClassName(responseClass: string): ProductConfig;
+    static getByDocType(docType: string): ProductConfig;
+}

package/src/constants.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProductConfigs = void 0;
+const api_1 = require("./api");
+const documents_1 = require("./documents");
+class ProductConfigs {
+    static getByResponseClassName(responseClass) {
+        const config = this.configs.find((element) => element.responseClass.name === responseClass);
+        if (config === undefined) {
+            throw `Unknown response class: ${responseClass}`;
+        }
+        return config;
+    }
+    static getByDocType(docType) {
+        const config = this.configs.find((element) => element.docType === docType);
+        if (config === undefined) {
+            throw `Unknown document type: ${docType}`;
+        }
+        return config;
+    }
+}
+exports.ProductConfigs = ProductConfigs;
+ProductConfigs.configs = [
+    {
+        description: "Invoice",
+        docType: documents_1.DOC_TYPE_INVOICE,
+        responseClass: api_1.InvoiceResponse,
+        fullText: true,
+    },
+    {
+        description: "Expense Receipt",
+        docType: documents_1.DOC_TYPE_RECEIPT,
+        responseClass: api_1.ReceiptResponse,
+        fullText: true,
+    },
+    {
+        description: "Passport",
+        docType: documents_1.DOC_TYPE_PASSPORT,
+        responseClass: api_1.PassportResponse,
+        fullText: false,
+    },
+    {
+        description: "Financial Document (receipt or invoice)",
+        docType: documents_1.DOC_TYPE_FINANCIAL,
+        responseClass: api_1.FinancialDocResponse,
+        fullText: true,
+    },
+    {
+        description: "A custom document",
+        docType: documents_1.DOC_TYPE_CUSTOM,
+        responseClass: api_1.CustomResponse,
+        fullText: false,
+    },
+];

package/src/documents/custom.d.ts

@@ -0,0 +1,14 @@
+import { Document, DocumentConstructorProps } from "./document";
+import { ClassificationField, ListField } from "../fields";
+import { stringDict } from "../fields/field";
+export interface CustomDocConstructorProps extends DocumentConstructorProps {
+    documentType: string;
+}
+export declare class CustomDocument extends Document {
+    fields: Map<string, ListField>;
+    classifications: Map<string, ClassificationField>;
+    readonly documentType: string;
+    constructor({ inputFile, apiPrediction, pageId, documentType, }: CustomDocConstructorProps);
+    protected setField(fieldName: string, apiPrediction: stringDict, pageId: number | undefined): void;
+    toString(): string;
+}

package/src/documents/custom.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomDocument = void 0;
+const document_1 = require("./document");
+const fields_1 = require("../fields");
+class CustomDocument extends document_1.Document {
+    constructor({ inputFile, apiPrediction, pageId, documentType, }) {
+        super(inputFile, pageId);
+        this.fields = new Map();
+        this.classifications = new Map();
+        this.documentType = documentType;
+        Object.keys(apiPrediction).forEach((fieldName) => {
+            this.setField(fieldName, apiPrediction, pageId);
+        });
+    }
+    setField(fieldName, apiPrediction, pageId) {
+        // Currently, two types of fields possible in a custom API response:
+        // fields having a list of values, and classification fields.
+        const fieldPrediction = apiPrediction[fieldName];
+        if (fieldPrediction["values"] !== undefined) {
+            // Only value lists have the 'values' attribute.
+            this.fields.set(fieldName, new fields_1.ListField({
+                prediction: fieldPrediction,
+                pageId: pageId,
+            }));
+        }
+        else if (fieldPrediction["value"] !== undefined) {
+            // Only classifications have the 'value' attribute.
+            this.classifications.set(fieldName, new fields_1.ClassificationField({ prediction: fieldPrediction }));
+        }
+        else {
+            throw "Unknown API field type";
+        }
+    }
+    toString() {
+        let outStr = `----- ${this.documentType} -----`;
+        outStr += `\nFilename: ${this.filename}`.trimEnd();
+        this.classifications.forEach((fieldData, name) => {
+            outStr += `\n${name}: ${fieldData}`.trimEnd();
+        });
+        this.fields.forEach((fieldData, name) => {
+            outStr += `\n${name}: ${fieldData}`.trimEnd();
+        });
+        outStr += "\n----------------------\n";
+        return outStr;
+    }
+}
+exports.CustomDocument = CustomDocument;

package/src/documents/document.d.ts

@@ -0,0 +1,38 @@
+import { Input } from "../inputs";
+import { FullText } from "../fields";
+export interface DocumentConstructorProps {
+    apiPrediction: {
+        [index: string]: any;
+    };
+    inputFile?: Input;
+    pageId?: number;
+    fullText?: FullText;
+}
+export declare class Document {
+    checklist: {
+        [index: string]: boolean;
+    };
+    mimeType: string | undefined;
+    filename: string;
+    filepath: string | undefined;
+    fullText?: FullText;
+    pageId?: number | undefined;
+    /**
+     * Takes a list of Documents and return one Document where
+     * each field is set with the maximum probability field
+     * @param {Input} inputFile - input file given to parse the document
+     * @param {number} pageId - Page ID for multi-page document
+     * @param {FullText} fullText - full OCR extracted text
+     */
+    constructor(inputFile?: Input, pageId?: number, fullText?: FullText);
+    clone(): any;
+    /** return true if all checklist of the document if true */
+    checkAll(): boolean;
+    /**
+     * Takes a list of Documents and return one Document where
+     * each field is set with the maximum probability field
+     * @param {Array<Document>} documents - A list of Documents
+     */
+    static mergePages(documents: any): any;
+    static cleanOutString(outStr: string): string;
+}