mindee 1.4.0 → 2.0.0

package/dist/src/fields/fullText.js

@@ -0,0 +1,89 @@
+"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.FullText = void 0;
+const geometry = __importStar(require("../geometry"));
+function orderLines(fullText) {
+    const lines = [];
+    const idxs = [];
+    let current = undefined;
+    fullText.forEach(() => {
+        let line = [];
+        fullText.forEach((word, idx) => {
+            if (!idxs.includes(idx)) {
+                if (current === undefined) {
+                    current = word;
+                    idxs.push(idx);
+                    line = [current];
+                }
+                else {
+                    const centroid = geometry.getCentroid(word.polygon);
+                    if (geometry.isPointInPolygonY(centroid, current.polygon)) {
+                        line.push(word);
+                        idxs.push(idx);
+                    }
+                }
+            }
+        });
+        current = undefined;
+        if (line.length > 0) {
+            lines.push(line);
+        }
+    });
+    const orderedLines = [];
+    lines.forEach((line) => {
+        const sortedLine = line.sort((a, b) => {
+            return geometry.relativeX(a.polygon) - geometry.relativeX(b.polygon);
+        });
+        orderedLines.push(sortedLine);
+    });
+    orderedLines.reverse();
+    return orderedLines;
+}
+class FullText {
+    constructor() {
+        this.words = [];
+    }
+    /**
+     * Order all text on a page into lines.
+     * WARNING: This feature is experimental.
+     */
+    toLines() {
+        return orderLines(this.words);
+    }
+    /**
+     * WARNING: This feature is experimental.
+     */
+    toString() {
+        let outStr = "";
+        const lines = this.toLines();
+        lines.forEach((line) => {
+            const lineStr = line.map((word) => word.text).join(" ");
+            outStr += `${lineStr}\n`;
+        });
+        return outStr;
+    }
+}
+exports.FullText = FullText;

package/dist/src/fields/index.d.ts

@@ -0,0 +1,11 @@
+export { TaxField } from "./tax";
+export { PaymentDetails } from "./paymentDetails";
+export { Orientation } from "./orientation";
+export { Locale } from "./locale";
+export { Amount } from "./amount";
+export { DateField } from "./date";
+export { BaseField } from "./field";
+export { Field } from "./field";
+export { ListField, ListFieldItem, ClassificationField } from "./customDocs";
+export { FullText } from "./fullText";
+export { CompanyRegistration } from "./companyRegistration";

package/dist/src/fields/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompanyRegistration = exports.FullText = exports.ClassificationField = exports.ListFieldItem = exports.ListField = exports.Field = exports.BaseField = exports.DateField = exports.Amount = exports.Locale = exports.Orientation = exports.PaymentDetails = exports.TaxField = void 0;
+var tax_1 = require("./tax");
+Object.defineProperty(exports, "TaxField", { enumerable: true, get: function () { return tax_1.TaxField; } });
+var paymentDetails_1 = require("./paymentDetails");
+Object.defineProperty(exports, "PaymentDetails", { enumerable: true, get: function () { return paymentDetails_1.PaymentDetails; } });
+var orientation_1 = require("./orientation");
+Object.defineProperty(exports, "Orientation", { enumerable: true, get: function () { return orientation_1.Orientation; } });
+var locale_1 = require("./locale");
+Object.defineProperty(exports, "Locale", { enumerable: true, get: function () { return locale_1.Locale; } });
+var amount_1 = require("./amount");
+Object.defineProperty(exports, "Amount", { enumerable: true, get: function () { return amount_1.Amount; } });
+var date_1 = require("./date");
+Object.defineProperty(exports, "DateField", { enumerable: true, get: function () { return date_1.DateField; } });
+var field_1 = require("./field");
+Object.defineProperty(exports, "BaseField", { enumerable: true, get: function () { return field_1.BaseField; } });
+var field_2 = require("./field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_2.Field; } });
+var customDocs_1 = require("./customDocs");
+Object.defineProperty(exports, "ListField", { enumerable: true, get: function () { return customDocs_1.ListField; } });
+Object.defineProperty(exports, "ListFieldItem", { enumerable: true, get: function () { return customDocs_1.ListFieldItem; } });
+Object.defineProperty(exports, "ClassificationField", { enumerable: true, get: function () { return customDocs_1.ClassificationField; } });
+var fullText_1 = require("./fullText");
+Object.defineProperty(exports, "FullText", { enumerable: true, get: function () { return fullText_1.FullText; } });
+var companyRegistration_1 = require("./companyRegistration");
+Object.defineProperty(exports, "CompanyRegistration", { enumerable: true, get: function () { return companyRegistration_1.CompanyRegistration; } });

package/dist/src/fields/locale.d.ts

@@ -0,0 +1,13 @@
+import { Field } from "./field";
+export declare class Locale extends Field {
+    language: string | undefined;
+    country: string | undefined;
+    currency: string | undefined;
+    /**
+     * @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)
+     */
+    constructor({ prediction, reconstructed, valueKey }: any);
+    toString(): string;
+}

package/dist/src/fields/locale.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Locale = void 0;
+const field_1 = require("./field");
+class Locale 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)
+     */
+    constructor({ prediction, reconstructed = false, valueKey = "value" }) {
+        super({ prediction, valueKey, reconstructed });
+        this.language = undefined;
+        this.country = undefined;
+        this.currency = undefined;
+        if ("language" in prediction && prediction.language !== "N/A")
+            this.language = prediction.language;
+        if ("country" in prediction && prediction.country !== "N/A")
+            this.country = prediction.country;
+        if ("currency" in prediction && prediction.currency !== "N/A")
+            this.currency = prediction.currency;
+    }
+    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.Locale = Locale;

package/dist/src/fields/orientation.d.ts

@@ -0,0 +1,10 @@
+import { Field } from "./field";
+export declare class Orientation 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 {Integer} pageId - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey, reconstructed, pageId, }: any);
+}

package/dist/src/fields/orientation.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Orientation = void 0;
+const field_1 = require("./field");
+class Orientation 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 {Integer} pageId - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey = "degrees", reconstructed = false, pageId, }) {
+        const orientations = [0, 90, 180, 270];
+        super({ prediction, valueKey, reconstructed, pageId });
+        this.value = parseInt(prediction[valueKey]);
+        if (isNaN(this.value))
+            this.confidence = 0.0;
+        if (!orientations.includes(this.value))
+            this.value = 0;
+    }
+}
+exports.Orientation = Orientation;

package/dist/src/fields/paymentDetails.d.ts

@@ -0,0 +1,31 @@
+import { Field } from "./field";
+interface PaymentDetailsConstructor {
+    prediction: any;
+    valueKey?: string;
+    accountNumberKey?: string;
+    ibanKey?: string;
+    routingNumberKey?: string;
+    swiftKey?: string;
+    reconstructed?: boolean;
+    pageId?: number;
+}
+export declare class PaymentDetails extends Field {
+    #private;
+    accountNumber: number | undefined;
+    iban: string | undefined;
+    routingNumber: number | undefined;
+    swift: number | undefined;
+    /**
+     * @param {Object} prediction - Prediction object from HTTP response
+     * @param {String} valueKey - Key to use in the prediction dict to get the iban
+     * @param {String} accountNumberKey - Key to use to get the account number in the prediction dict
+     * @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 {Integer} pageId - Page ID for multi-page document
+     */
+    constructor({ prediction, valueKey, accountNumberKey, ibanKey, routingNumberKey, swiftKey, reconstructed, pageId, }: PaymentDetailsConstructor);
+    toString(): string;
+}
+export {};

package/dist/src/fields/paymentDetails.js

@@ -0,0 +1,58 @@
+"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 _PaymentDetails_instances, _PaymentDetails_setKey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentDetails = void 0;
+const field_1 = require("./field");
+class PaymentDetails 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
+     * @param {String} accountNumberKey - Key to use to get the account number in the prediction dict
+     * @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 {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, }) {
+        super({ prediction, valueKey, reconstructed, pageId });
+        _PaymentDetails_instances.add(this);
+        this.accountNumber = undefined;
+        this.iban = undefined;
+        this.routingNumber = undefined;
+        this.swift = undefined;
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[accountNumberKey], "accountNumber");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[ibanKey], "iban");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[routingNumberKey], "routingNumber");
+        __classPrivateFieldGet(this, _PaymentDetails_instances, "m", _PaymentDetails_setKey).call(this, prediction[swiftKey], "swift");
+    }
+    toString() {
+        let str = "";
+        const keys = ["accountNumber", "iban", "routingNumber", "swift"];
+        for (const key of keys) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (this[key])
+                str += `${this[key]}; `;
+        }
+        return str;
+    }
+}
+exports.PaymentDetails = PaymentDetails;
+_PaymentDetails_instances = new WeakSet(), _PaymentDetails_setKey = function _PaymentDetails_setKey(value, key) {
+    if (typeof value === "string" && value !== "N/A") {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this[key] = value;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this[key] = undefined;
+    }
+};

package/dist/src/fields/tax.d.ts

@@ -0,0 +1,30 @@
+import { Field } from "./field";
+interface TaxConstructor {
+    prediction: any;
+    valueKey?: string;
+    rateKey?: string;
+    codeKey?: string;
+    reconstructed?: boolean;
+    pageId?: number;
+}
+export declare class TaxField extends Field {
+    /** The tax amount. */
+    value?: number;
+    /**  The tax code (HST, GST... for Canadian; City Tax, State tax for US, etc..). */
+    rate?: number;
+    /** The tax rate. */
+    code?: string;
+    /** The document page on which the information was found. */
+    pageId: 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, reconstructed, pageId, }: TaxConstructor);
+    toString(): string;
+}
+export {};

package/dist/src/fields/tax.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaxField = void 0;
+const field_1 = require("./field");
+const amount_1 = require("./amount");
+class TaxField 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 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", reconstructed = false, pageId = undefined, }) {
+        var _a;
+        super({ prediction, valueKey, reconstructed, pageId });
+        /** The tax amount. */
+        this.value = undefined;
+        /**  The tax code (HST, GST... for Canadian; City Tax, State tax for US, etc..). */
+        this.rate = undefined;
+        /** The tax rate. */
+        this.code = undefined;
+        this.rate = +parseFloat(prediction[rateKey]);
+        if (isNaN(this.rate))
+            this.rate = undefined;
+        this.code = (_a = prediction[codeKey]) === null || _a === void 0 ? void 0 : _a.toString();
+        if (this.code === "N/A" || this.code === "None") {
+            this.code = undefined;
+        }
+        this.value = parseFloat(prediction[valueKey]);
+        if (isNaN(this.value)) {
+            this.value = undefined;
+            this.confidence = 0.0;
+        }
+    }
+    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}`;
+        }
+        return outStr.trim();
+    }
+}
+exports.TaxField = TaxField;

package/dist/src/geometry.d.ts

@@ -0,0 +1,59 @@
+declare type MinMax = {
+    min: number;
+    max: number;
+};
+/** A point on the document defined by 2 coordinates: X, Y */
+export declare type Point = [number, number];
+/** A bounding box defined by 4 coordinates: xMin, yMin, xMax, yMax */
+export declare type BoundingBox = [number, number, number, number];
+/** A polygon, composed of several Points. */
+export declare type Polygon = Array<Point>;
+/**
+ * Given a Polygon, calculate a polygon that encompasses all points.
+ */
+export declare function getBboxAsPolygon(polygon: Polygon): Polygon;
+/**
+ * Given a Polygon, calculate a bounding box that encompasses all points.
+ */
+export declare function getBbox(polygon: Polygon): BoundingBox;
+/**
+ * Get the central point (centroid) given a list of points.
+ */
+export declare function getCentroid(vertices: Array<Point>): Point;
+/**
+ * Determine if a Point is within two Y coordinates.
+ */
+export declare function isPointInY(centroid: Point, yMin: number, yMax: number): boolean;
+/**
+ * Get the maximum and minimum Y coordinates in a given list of Points.
+ */
+export declare function getMinMaxY(vertices: Array<Point>): MinMax;
+/**
+ * Determine if a Point is within a Polygon's Y axis.
+ */
+export declare function isPointInPolygonY(centroid: Point, polygon: Polygon): boolean;
+/**
+ * Calculate the relative Y position of a Polygon.
+ *
+ * Can be used to order (sort) words in the same column.
+ */
+export declare function relativeY(polygon: Polygon): number;
+/**
+ * Determine if a Point is within two X coordinates.
+ */
+export declare function isPointInX(centroid: Point, xMin: number, xMax: number): boolean;
+/**
+ * Get the maximum and minimum X coordinates in a given list of Points.
+ */
+export declare function getMinMaxX(vertices: Array<Point>): MinMax;
+/**
+ * Determine if a Point is within a Polygon's X axis.
+ */
+export declare function isPointInPolygonX(centroid: Point, polygon: Polygon): boolean;
+/**
+ * Calculate the relative X position of a Polygon.
+ *
+ * Can be used to order (sort) words in the same line.
+ */
+export declare function relativeX(polygon: Polygon): number;
+export {};

package/dist/src/geometry.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relativeX = exports.isPointInPolygonX = exports.getMinMaxX = exports.isPointInX = exports.relativeY = exports.isPointInPolygonY = exports.getMinMaxY = exports.isPointInY = exports.getCentroid = exports.getBbox = exports.getBboxAsPolygon = void 0;
+/**
+ * Given a Polygon, calculate a polygon that encompasses all points.
+ */
+function getBboxAsPolygon(polygon) {
+    const bbox = getBbox(polygon);
+    return [
+        [bbox[0], bbox[1]],
+        [bbox[2], bbox[1]],
+        [bbox[2], bbox[3]],
+        [bbox[0], bbox[3]],
+    ];
+}
+exports.getBboxAsPolygon = getBboxAsPolygon;
+/**
+ * Given a Polygon, calculate a bounding box that encompasses all points.
+ */
+function getBbox(polygon) {
+    const allY = polygon.map((point) => point[1]);
+    const allX = polygon.map((point) => point[0]);
+    const yMin = Math.min(...allY);
+    const yMax = Math.max(...allY);
+    const xMin = Math.min(...allX);
+    const xMax = Math.max(...allX);
+    return [xMin, yMin, xMax, yMax];
+}
+exports.getBbox = getBbox;
+/**
+ * Get the central point (centroid) given a list of points.
+ */
+function getCentroid(vertices) {
+    const numbVertices = vertices.length;
+    const xSum = vertices
+        .map((point) => point[0])
+        .reduce((prev, cur) => prev + cur);
+    const ySum = vertices
+        .map((point) => point[1])
+        .reduce((prev, cur) => prev + cur);
+    return [xSum / numbVertices, ySum / numbVertices];
+}
+exports.getCentroid = getCentroid;
+/**
+ * Determine if a Point is within two Y coordinates.
+ */
+function isPointInY(centroid, yMin, yMax) {
+    return yMin <= centroid[1] && centroid[1] <= yMax;
+}
+exports.isPointInY = isPointInY;
+/**
+ * Get the maximum and minimum Y coordinates in a given list of Points.
+ */
+function getMinMaxY(vertices) {
+    const points = vertices.map((point) => point[1]);
+    return { min: Math.min(...points), max: Math.max(...points) };
+}
+exports.getMinMaxY = getMinMaxY;
+/**
+ * Determine if a Point is within a Polygon's Y axis.
+ */
+function isPointInPolygonY(centroid, polygon) {
+    const yCoords = getMinMaxY(polygon);
+    return isPointInY(centroid, yCoords.min, yCoords.max);
+}
+exports.isPointInPolygonY = isPointInPolygonY;
+/**
+ * Calculate the relative Y position of a Polygon.
+ *
+ * Can be used to order (sort) words in the same column.
+ */
+function relativeY(polygon) {
+    const sum = polygon
+        .map((point) => point[1])
+        .reduce((prev, cur) => prev + cur);
+    return polygon.length * sum;
+}
+exports.relativeY = relativeY;
+/**
+ * Determine if a Point is within two X coordinates.
+ */
+function isPointInX(centroid, xMin, xMax) {
+    return xMin <= centroid[0] && centroid[0] <= xMax;
+}
+exports.isPointInX = isPointInX;
+/**
+ * Get the maximum and minimum X coordinates in a given list of Points.
+ */
+function getMinMaxX(vertices) {
+    const points = vertices.map((point) => point[0]);
+    return { min: Math.min(...points), max: Math.max(...points) };
+}
+exports.getMinMaxX = getMinMaxX;
+/**
+ * Determine if a Point is within a Polygon's X axis.
+ */
+function isPointInPolygonX(centroid, polygon) {
+    const xCoords = getMinMaxX(polygon);
+    return isPointInX(centroid, xCoords.min, xCoords.max);
+}
+exports.isPointInPolygonX = isPointInPolygonX;
+/**
+ * Calculate the relative X position of a Polygon.
+ *
+ * Can be used to order (sort) words in the same line.
+ */
+function relativeX(polygon) {
+    const sum = polygon
+        .map((point) => point[0])
+        .reduce((prev, cur) => prev + cur);
+    return polygon.length * sum;
+}
+exports.relativeX = relativeX;

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export { Response, FinancialDocResponse, InvoiceResponse, PassportResponse, ReceiptResponse, CustomResponse, } from "./api";
+export { Client } from "./client";

package/dist/src/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = 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; } });
+var client_1 = require("./client");
+Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });

package/dist/src/inputs.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream } from "fs";
+import { Buffer } from "node:buffer";
+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 class Input {
+    MAX_DOC_PAGES: number;
+    inputType: string;
+    filename: string;
+    filepath?: string;
+    mimeType: string;
+    fileObject: Buffer;
+    /**
+     * @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>;
+    countPages(): Promise<number>;
+    /** Merge PDF pages */
+    cutPdf(): Promise<void>;
+}
+interface PathInputProps {
+    inputPath: string;
+}
+export declare class PathInput extends Input {
+    readonly inputPath: string;
+    constructor({ inputPath }: PathInputProps);
+    init(): Promise<void>;
+}
+interface Base64InputProps {
+    inputString: string;
+    filename: string;
+}
+export declare class Base64Input extends Input {
+    private inputString;
+    constructor({ inputString, filename }: Base64InputProps);
+    init(): Promise<void>;
+}
+interface StreamInputProps {
+    inputStream: ReadStream;
+    filename: string;
+}
+export declare class StreamInput extends Input {
+    private inputStream;
+    constructor({ inputStream, filename }: StreamInputProps);
+    init(): Promise<void>;
+    stream2buffer(stream: ReadStream): Promise<Buffer>;
+}
+interface BytesInputProps {
+    inputBytes: string;
+    filename: string;
+}
+export declare class BytesInput extends Input {
+    private inputBytes;
+    constructor({ inputBytes, filename }: BytesInputProps);
+    init(): Promise<void>;
+}
+export {};