mindee 2.1.1 → 3.0.1

package/src/documents/receipt/receiptV4.js

@@ -0,0 +1,96 @@
+"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 _ReceiptV4_instances, _ReceiptV4_initFromApiPrediction;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptV4 = void 0;
+const document_1 = require("../document");
+const fields_1 = require("../../fields");
+const tax_1 = require("./tax");
+class ReceiptV4 extends document_1.Document {
+    constructor({ prediction, orientation = undefined, extras = undefined, inputSource = undefined, fullText = undefined, pageId = undefined, }) {
+        super({
+            inputSource: inputSource,
+            pageId: pageId,
+            orientation: orientation,
+            extras: extras,
+            fullText: fullText,
+        });
+        _ReceiptV4_instances.add(this);
+        /** List of taxes detected on the receipt. */
+        this.taxes = [];
+        __classPrivateFieldGet(this, _ReceiptV4_instances, "m", _ReceiptV4_initFromApiPrediction).call(this, prediction, pageId);
+    }
+    toString() {
+        const taxes = this.taxes.map((item) => item.toString()).join("\n       ");
+        const outStr = `----- Receipt V4 -----
+Filename: ${this.filename}
+Total amount: ${this.totalAmount}
+Total net: ${this.totalNet}
+Tip: ${this.tip}
+Date: ${this.date}
+Category: ${this.category}
+Time: ${this.time}
+Supplier name: ${this.supplier}
+Taxes: ${taxes}
+Total taxes: ${this.totalTax}
+Locale: ${this.locale}
+----------------------
+`;
+        return ReceiptV4.cleanOutString(outStr);
+    }
+}
+exports.ReceiptV4 = ReceiptV4;
+_ReceiptV4_instances = new WeakSet(), _ReceiptV4_initFromApiPrediction = function _ReceiptV4_initFromApiPrediction(apiPrediction, pageId) {
+    this.locale = new fields_1.Locale({
+        prediction: apiPrediction.locale,
+        pageId: pageId,
+    });
+    this.totalTax = new fields_1.Amount({
+        prediction: apiPrediction.total_tax,
+        valueKey: "value",
+        pageId: pageId,
+    });
+    this.totalAmount = new fields_1.Amount({
+        prediction: apiPrediction.total_amount,
+        valueKey: "value",
+        pageId: pageId,
+    });
+    this.totalNet = new fields_1.Amount({
+        prediction: apiPrediction.total_net,
+        valueKey: "value",
+        pageId: pageId,
+    });
+    this.tip = new fields_1.Amount({
+        prediction: apiPrediction.tip,
+        valueKey: "value",
+        pageId: pageId,
+    });
+    this.date = new fields_1.DateField({
+        prediction: apiPrediction.date,
+        pageId: pageId,
+    });
+    this.category = new fields_1.Field({
+        prediction: apiPrediction.category,
+        pageId: pageId,
+    });
+    this.supplier = new fields_1.Field({
+        prediction: apiPrediction.supplier,
+        pageId: pageId,
+    });
+    this.time = new fields_1.Field({
+        prediction: apiPrediction.time,
+        pageId: pageId,
+    });
+    apiPrediction.taxes.map((taxPrediction) => this.taxes.push(new tax_1.ReceiptTaxField({
+        prediction: taxPrediction,
+        pageId: pageId,
+        valueKey: "value",
+        rateKey: "rate",
+        codeKey: "code",
+        basisKey: "basis",
+    })));
+};

package/src/documents/receipt/tax.d.ts

@@ -0,0 +1,25 @@
+import { TaxField } from "../../fields";
+interface ReceiptTaxConstructor {
+    prediction: any;
+    valueKey?: string;
+    rateKey?: string;
+    codeKey?: string;
+    basisKey?: string;
+    reconstructed?: boolean;
+    pageId?: number;
+}
+export declare class ReceiptTaxField extends TaxField {
+    /**  The tax base */
+    basis?: number;
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+     * @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 {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey, rateKey, codeKey, basisKey, reconstructed, pageId, }: ReceiptTaxConstructor);
+    toString(): string;
+}
+export {};

package/src/documents/receipt/tax.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReceiptTaxField = void 0;
+const fields_1 = require("../../fields");
+const amount_1 = require("../../fields/amount");
+class ReceiptTaxField extends fields_1.TaxField {
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the tax value
+     * @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 {Boolean} reconstructed - Does the object is reconstructed (not extracted by the API)
+     * @param {Integer} pageNumber - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey = "value", rateKey = "rate", codeKey = "code", basisKey = "basis", reconstructed = false, pageId = undefined, }) {
+        super({ prediction, valueKey, rateKey, codeKey, reconstructed, pageId });
+        /**  The tax base */
+        this.basis = undefined;
+        this.basis = parseFloat(prediction[basisKey]);
+        if (isNaN(this.basis))
+            this.basis = undefined;
+    }
+    toString() {
+        let outStr = "";
+        if (this.value !== undefined) {
+            outStr += `${(0, amount_1.floatToString)(this.value)}`;
+        }
+        if (this.rate !== undefined) {
+            outStr += ` ${(0, amount_1.floatToString)(this.rate)}%`;
+        }
+        if (this.code !== undefined) {
+            outStr += ` ${this.code}`;
+        }
+        if (this.basis !== undefined) {
+            outStr += ` ${this.basis}`;
+        }
+        return outStr.trim();
+    }
+}
+exports.ReceiptTaxField = ReceiptTaxField;

package/src/documents/us/bankCheck/bankCheckV1.d.ts

@@ -0,0 +1,3 @@
+import { Document } from "../../document";
+export declare class BankCheckV1 extends Document {
+}

package/src/documents/us/bankCheck/bankCheckV1.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BankCheckV1 = void 0;
+const document_1 = require("../../document");
+class BankCheckV1 extends document_1.Document {
+}
+exports.BankCheckV1 = BankCheckV1;

package/src/errors/MindeeError.d.ts

@@ -0,0 +1,3 @@
+export declare class MindeeError extends Error {
+    constructor(message: string);
+}

package/src/errors/MindeeError.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindeeError = void 0;
+class MindeeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MindeeError";
+    }
+}
+exports.MindeeError = MindeeError;

package/src/errors/index.d.ts

@@ -0,0 +1 @@
+export { MindeeError } from "./MindeeError";

package/src/errors/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MindeeError = void 0;
+var MindeeError_1 = require("./MindeeError");
+Object.defineProperty(exports, "MindeeError", { enumerable: true, get: function () { return MindeeError_1.MindeeError; } });

package/src/fields/{customDocs.d.ts → apiBuilder.d.ts}

@@ -2,6 +2,10 @@ import { FieldConstructor, stringDict } from "./field";
 import { Polygon } from "../geometry";
 export declare class ClassificationField {
     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;
@@ -34,7 +38,7 @@ export declare class ListField {
     /** True if the field was reconstructed or computed using other fields. */
     reconstructed: boolean;
     /** The document page on which the information was found. */
-    pageId?: number;
+    pageId: number;
     constructor({ prediction, reconstructed, pageId }: FieldConstructor);
     contentsList(): Array<any>;
     contentsString(separator?: string): string;

package/src/fields/index.d.ts

@@ -5,7 +5,7 @@ export { Locale } from "./locale";
 export { Amount } from "./amount";
 export { DateField } from "./date";
 export { BaseField, stringDict, Field } from "./field";
-export { ListField, ListFieldValue, ClassificationField } from "./customDocs";
+export { ListField, ListFieldValue, ClassificationField } from "./apiBuilder";
 export { FullText } from "./fullText";
 export { CompanyRegistration } from "./companyRegistration";
 export { CropperField } from "./cropper";

package/src/fields/index.js

@@ -16,10 +16,10 @@ Object.defineProperty(exports, "DateField", { enumerable: true, get: function ()
 var field_1 = require("./field");
 Object.defineProperty(exports, "BaseField", { enumerable: true, get: function () { return field_1.BaseField; } });
 Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });
-var customDocs_1 = require("./customDocs");
-Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return customDocs_1.ListField; } });
-Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return customDocs_1.ListFieldValue; } });
-Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return customDocs_1.ClassificationField; } });
+var apiBuilder_1 = require("./apiBuilder");
+Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return apiBuilder_1.ListField; } });
+Object.defineProperty(exports, "ListFieldValue", { enumerable: true, get: function () { return apiBuilder_1.ListFieldValue; } });
+Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return apiBuilder_1.ClassificationField; } });
 var fullText_1 = require("./fullText");
 Object.defineProperty(exports, "FullText", { enumerable: true, get: function () { return fullText_1.FullText; } });
 var companyRegistration_1 = require("./companyRegistration");

package/src/index.d.ts

@@ -1,2 +1,3 @@
-export { Response, FinancialDocResponse, InvoiceResponse, PassportResponse, ReceiptResponse, CustomResponse, CropperResponse, } from "./api";
+export { CustomV1, FinancialDocumentV1, InvoiceV3, PassportV1, ReceiptV3, ReceiptV4, CropperV1, } from "./documents";
 export { Client } from "./client";
+export { PageOptionsOperation } from "./inputs";

package/src/index.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Client = exports.CropperResponse = exports.CustomResponse = exports.ReceiptResponse = exports.PassportResponse = exports.InvoiceResponse = exports.FinancialDocResponse = exports.Response = void 0;
-var api_1 = require("./api");
-Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return api_1.Response; } });
-Object.defineProperty(exports, "FinancialDocResponse", { enumerable: true, get: function () { return api_1.FinancialDocResponse; } });
-Object.defineProperty(exports, "InvoiceResponse", { enumerable: true, get: function () { return api_1.InvoiceResponse; } });
-Object.defineProperty(exports, "PassportResponse", { enumerable: true, get: function () { return api_1.PassportResponse; } });
-Object.defineProperty(exports, "ReceiptResponse", { enumerable: true, get: function () { return api_1.ReceiptResponse; } });
-Object.defineProperty(exports, "CustomResponse", { enumerable: true, get: function () { return api_1.CustomResponse; } });
-Object.defineProperty(exports, "CropperResponse", { enumerable: true, get: function () { return api_1.CropperResponse; } });
+exports.PageOptionsOperation = exports.Client = exports.CropperV1 = exports.ReceiptV4 = exports.ReceiptV3 = exports.PassportV1 = exports.InvoiceV3 = exports.FinancialDocumentV1 = exports.CustomV1 = void 0;
+var documents_1 = require("./documents");
+Object.defineProperty(exports, "CustomV1", { enumerable: true, get: function () { return documents_1.CustomV1; } });
+Object.defineProperty(exports, "FinancialDocumentV1", { enumerable: true, get: function () { return documents_1.FinancialDocumentV1; } });
+Object.defineProperty(exports, "InvoiceV3", { enumerable: true, get: function () { return documents_1.InvoiceV3; } });
+Object.defineProperty(exports, "PassportV1", { enumerable: true, get: function () { return documents_1.PassportV1; } });
+Object.defineProperty(exports, "ReceiptV3", { enumerable: true, get: function () { return documents_1.ReceiptV3; } });
+Object.defineProperty(exports, "ReceiptV4", { enumerable: true, get: function () { return documents_1.ReceiptV4; } });
+Object.defineProperty(exports, "CropperV1", { enumerable: true, get: function () { return documents_1.CropperV1; } });
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
+var inputs_1 = require("./inputs");
+Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return inputs_1.PageOptionsOperation; } });

package/src/inputs/base.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="node" />
+import { PageOptions } from "./pageOptions";
+interface InputProps {
+    inputType: string;
+}
+export declare const INPUT_TYPE_STREAM = "stream";
+export declare const INPUT_TYPE_BASE64 = "base64";
+export declare const INPUT_TYPE_BYTES = "bytes";
+export declare const INPUT_TYPE_PATH = "path";
+export declare const INPUT_TYPE_URL = "URL";
+export declare class InputSource {
+    inputType: string;
+    filename: string;
+    filepath?: string;
+    mimeType: string;
+    fileObject: Buffer | string;
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }: InputProps);
+    init(): Promise<void>;
+    isPdf(): boolean;
+    checkMimetype(): Promise<string>;
+    /**
+     * Merge PDF pages.
+     * @param pageOptions
+     */
+    cutPdf(pageOptions: PageOptions): Promise<void>;
+}
+export {};

package/src/inputs/base.js

@@ -0,0 +1,116 @@
+"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.InputSource = exports.INPUT_TYPE_URL = 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");
+const logger_1 = require("../logger");
+const handler_1 = require("../errors/handler");
+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";
+const MIMETYPES = new Map([
+    [".pdf", "application/pdf"],
+    [".heic", "image/heic"],
+    [".jpg", "image/jpeg"],
+    [".jpeg", "image/jpeg"],
+    [".png", "image/png"],
+    [".tif", "image/tiff"],
+    [".tiff", "image/tiff"],
+    [".webp", "image/webp"],
+]);
+const ALLOWED_INPUT_TYPES = [
+    exports.INPUT_TYPE_STREAM,
+    exports.INPUT_TYPE_BASE64,
+    exports.INPUT_TYPE_BYTES,
+    exports.INPUT_TYPE_PATH,
+    exports.INPUT_TYPE_URL,
+];
+class InputSource {
+    /**
+     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
+     *                             NB: dummy is only used for tests purposes
+     * @param {Boolean} cutPages
+     * NB: Because of async calls, init() should be called after creating the object
+     */
+    constructor({ inputType }) {
+        this.filename = "";
+        this.mimeType = "";
+        // Check if inputType is valid
+        if (!ALLOWED_INPUT_TYPES.includes(inputType)) {
+            const allowed = Array.from(ALLOWED_INPUT_TYPES.keys()).join(", ");
+            handler_1.errorHandler.throw(new Error(`Invalid input type, must be one of ${allowed}.`));
+        }
+        this.inputType = inputType;
+        logger_1.logger.debug(`Loading file from: ${inputType}`);
+    }
+    async init() {
+        throw new Error("not Implemented");
+    }
+    isPdf() {
+        return this.mimeType === "application/pdf";
+    }
+    async checkMimetype() {
+        if (!(this.fileObject instanceof Buffer)) {
+            throw new Error(`MIME type cannot be verified on input source of type ${this.inputType}.`);
+        }
+        let mimeType;
+        const fileExt = path.extname(this.filename);
+        if (fileExt) {
+            mimeType = MIMETYPES.get(fileExt.toLowerCase()) || "";
+        }
+        else {
+            const guess = await fileType.fromBuffer(this.fileObject);
+            if (guess !== undefined) {
+                mimeType = guess.mime;
+            }
+            else {
+                throw "Could not determine the MIME type of the file";
+            }
+        }
+        if (!mimeType) {
+            const allowed = Array.from(MIMETYPES.keys()).join(", ");
+            const err = new Error(`Invalid file type, must be one of ${allowed}.`);
+            handler_1.errorHandler.throw(err);
+        }
+        logger_1.logger.debug(`File is of type: ${mimeType}`);
+        return mimeType;
+    }
+    /**
+     * Merge PDF pages.
+     * @param pageOptions
+     */
+    async cutPdf(pageOptions) {
+        if (!(this.fileObject instanceof Buffer)) {
+            throw new Error(`Cannot modify an input source of type ${this.inputType}.`);
+        }
+        const processedPdf = await (0, pdf_1.extractPages)(this.fileObject, pageOptions);
+        this.fileObject = processedPdf.file;
+    }
+}
+exports.InputSource = InputSource;

package/src/inputs/index.d.ts

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

package/src/inputs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INPUT_TYPE_URL = exports.INPUT_TYPE_STREAM = exports.INPUT_TYPE_PATH = exports.INPUT_TYPE_BYTES = exports.INPUT_TYPE_BASE64 = exports.InputSource = 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");
+Object.defineProperty(exports, "Base64Input", { enumerable: true, get: function () { return sources_1.Base64Input; } });
+Object.defineProperty(exports, "BytesInput", { enumerable: true, get: function () { return sources_1.BytesInput; } });
+Object.defineProperty(exports, "PathInput", { enumerable: true, get: function () { return sources_1.PathInput; } });
+Object.defineProperty(exports, "StreamInput", { enumerable: true, get: function () { return sources_1.StreamInput; } });
+Object.defineProperty(exports, "UrlInput", { enumerable: true, get: function () { return sources_1.UrlInput; } });
+var base_1 = require("./base");
+Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return base_1.InputSource; } });
+Object.defineProperty(exports, "INPUT_TYPE_BASE64", { enumerable: true, get: function () { return base_1.INPUT_TYPE_BASE64; } });
+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; } });

package/src/inputs/pageOptions.d.ts

@@ -0,0 +1,20 @@
+export interface PageOptions {
+    /**
+     * Zero-based list of page indexes.
+     *
+     * A negative index can be used, indicating an offset from the end of the document.
+     *
+     * [0, -1] represents the fist and last pages of the document.
+     */
+    pageIndexes: number[];
+    /** Operation to apply on the document, given the `pageIndexes` specified. */
+    operation: PageOptionsOperation;
+    /**
+     * Apply the operation only if document has at least this many pages.
+     */
+    onMinPages: number;
+}
+export declare enum PageOptionsOperation {
+    KeepOnly = "KEEP_ONLY",
+    Remove = "REMOVE"
+}

package/src/inputs/pageOptions.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageOptionsOperation = void 0;
+var PageOptionsOperation;
+(function (PageOptionsOperation) {
+    PageOptionsOperation["KeepOnly"] = "KEEP_ONLY";
+    PageOptionsOperation["Remove"] = "REMOVE";
+})(PageOptionsOperation = exports.PageOptionsOperation || (exports.PageOptionsOperation = {}));

package/src/inputs/sources.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream } from "fs";
+import { Buffer } from "node:buffer";
+import { InputSource } from "./base";
+interface PathInputProps {
+    inputPath: string;
+}
+export declare class PathInput extends InputSource {
+    readonly inputPath: string;
+    fileObject: Buffer;
+    constructor({ inputPath }: PathInputProps);
+    init(): Promise<void>;
+}
+interface Base64InputProps {
+    inputString: string;
+    filename: string;
+}
+export declare class Base64Input extends InputSource {
+    private inputString;
+    fileObject: Buffer;
+    constructor({ inputString, filename }: Base64InputProps);
+    init(): Promise<void>;
+}
+interface StreamInputProps {
+    inputStream: ReadStream;
+    filename: string;
+}
+export declare class StreamInput extends InputSource {
+    private readonly inputStream;
+    fileObject: Buffer;
+    constructor({ inputStream, filename }: StreamInputProps);
+    init(): Promise<void>;
+    stream2buffer(stream: ReadStream): Promise<Buffer>;
+}
+interface BytesInputProps {
+    inputBytes: string;
+    filename: string;
+}
+export declare class BytesInput extends InputSource {
+    private inputBytes;
+    fileObject: Buffer;
+    constructor({ inputBytes, filename }: BytesInputProps);
+    init(): Promise<void>;
+}
+interface UrlInputProps {
+    url: string;
+}
+export declare class UrlInput extends InputSource {
+    private readonly url;
+    fileObject: string;
+    constructor({ url }: UrlInputProps);
+    init(): Promise<void>;
+}
+export {};