mindee 3.10.2 → 4.0.1

package/src/geometry/minMax.d.ts

@@ -0,0 +1,4 @@
+export type MinMax = {
+    min: number;
+    max: number;
+};

package/src/geometry/minMax.js

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

package/src/geometry/point.d.ts

@@ -0,0 +1,2 @@
+/** A point on the document defined by 2 coordinates: X, Y */
+export type Point = [number, number];

package/src/geometry/point.js

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

package/src/geometry/polygon.d.ts

@@ -0,0 +1,4 @@
+import { Point } from "./point";
+/** A polygon, composed of several Points. */
+export declare class Polygon extends Array<Point> {
+}

package/src/geometry/polygon.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polygon = void 0;
+/** A polygon, composed of several Points. */
+class Polygon extends Array {
+}
+exports.Polygon = Polygon;

package/src/{geometry.d.ts → geometry/polygonUtils.d.ts}

@@ -1,35 +1,6 @@
-export type MinMax = {
-    min: number;
-    max: number;
-};
-/** A point on the document defined by 2 coordinates: X, Y */
-export type Point = [number, number];
-/** A simple bounding box defined by 4 coordinates: xMin, yMin, xMax, yMax */
-export type BBox = [number, number, number, number];
-/** A bounding box defined by 4 points. */
-export type BoundingBox = [Point, Point, Point, Point];
-/** A polygon, composed of several Points. */
-export type Polygon = Array<Point>;
-/**
- * Given a Polygon, calculate a polygon that encompasses all points.
- */
-export declare function getBoundingBox(polygon: Polygon): BoundingBox;
-/**
- * Given a BBox, generate the associated bounding box.
- */
-export declare function getBoundingBoxFromBBox(bbox: BBox): BoundingBox;
-/**
- * Given 2 bbox, merge them.
- */
-export declare function mergeBbox(bbox1: BBox, bbox2: BBox): BBox;
-/**
- * Given a Polygon, calculate a bounding box that encompasses all points.
- */
-export declare function getBbox(polygon: Polygon): BBox;
-/**
- * Given polygons, calculate a bounding box that encompasses all points.
- */
-export declare function getBBoxForPolygons(polygons: Polygon[]): BBox;
+import { MinMax } from "./minMax";
+import { Point } from "./point";
+import { Polygon } from "./polygon";
 /**
  * Get the central point (centroid) given a list of points.
  */
@@ -70,3 +41,7 @@ export declare function isPointInPolygonX(centroid: Point, polygon: Polygon): bo
  * Can be used to order (sort) words in the same line.
  */
 export declare function relativeX(polygon: Polygon): number;
+export declare function getMinYCoordinate(polygon: Polygon): number;
+export declare function getMinXCoordinate(polygon: Polygon): number;
+export declare function compareOnY(polygon1: Polygon, polygon2: Polygon): number;
+export declare function compareOnX(polygon1: Polygon, polygon2: Polygon): number;

package/src/{geometry.js → geometry/polygonUtils.js}

@@ -1,69 +1,6 @@
 "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.getBBoxForPolygons = exports.getBbox = exports.mergeBbox = exports.getBoundingBoxFromBBox = exports.getBoundingBox = void 0;
-/**
- * Given a Polygon, calculate a polygon that encompasses all points.
- */
-function getBoundingBox(polygon) {
-    const bbox = getBbox(polygon);
-    return [
-        [bbox[0], bbox[1]],
-        [bbox[2], bbox[1]],
-        [bbox[2], bbox[3]],
-        [bbox[0], bbox[3]],
-    ];
-}
-exports.getBoundingBox = getBoundingBox;
-/**
- * Given a BBox, generate the associated bounding box.
- */
-function getBoundingBoxFromBBox(bbox) {
-    return [
-        [bbox[0], bbox[1]],
-        [bbox[2], bbox[1]],
-        [bbox[2], bbox[3]],
-        [bbox[0], bbox[3]],
-    ];
-}
-exports.getBoundingBoxFromBBox = getBoundingBoxFromBBox;
-/**
- * Given 2 bbox, merge them.
- */
-function mergeBbox(bbox1, bbox2) {
-    return [
-        Math.min(bbox1[0], bbox2[0]),
-        Math.min(bbox1[1], bbox2[1]),
-        Math.max(bbox1[2], bbox2[2]),
-        Math.max(bbox1[3], bbox2[3]),
-    ];
-}
-exports.mergeBbox = mergeBbox;
-/**
- * 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;
-/**
- * Given polygons, calculate a bounding box that encompasses all points.
- */
-function getBBoxForPolygons(polygons) {
-    const allY = polygons.flatMap((polygon) => polygon.map((point) => point[1]));
-    const allX = polygons.flatMap((polygon) => 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.getBBoxForPolygons = getBBoxForPolygons;
+exports.compareOnX = exports.compareOnY = exports.getMinXCoordinate = exports.getMinYCoordinate = exports.relativeX = exports.isPointInPolygonX = exports.getMinMaxX = exports.isPointInX = exports.relativeY = exports.isPointInPolygonY = exports.getMinMaxY = exports.isPointInY = exports.getCentroid = void 0;
 /**
  * Get the central point (centroid) given a list of points.
  */
@@ -148,3 +85,43 @@ function relativeX(polygon) {
     return polygon.length * sum;
 }
 exports.relativeX = relativeX;
+function getMinYCoordinate(polygon) {
+    return polygon.sort((point1, point2) => {
+        if (point1[1] < point2[1]) {
+            return -1;
+        }
+        else if (point1[1] > point2[1]) {
+            return 1;
+        }
+        return 0;
+    })[0][1];
+}
+exports.getMinYCoordinate = getMinYCoordinate;
+function getMinXCoordinate(polygon) {
+    return polygon.sort((point1, point2) => {
+        if (point1[0] < point2[0]) {
+            return -1;
+        }
+        else if (point1[0] > point2[0]) {
+            return 1;
+        }
+        return 0;
+    })[0][0];
+}
+exports.getMinXCoordinate = getMinXCoordinate;
+function compareOnY(polygon1, polygon2) {
+    const sort = getMinYCoordinate(polygon1) - getMinYCoordinate(polygon2);
+    if (sort === 0) {
+        return 0;
+    }
+    return sort < 0 ? -1 : 1;
+}
+exports.compareOnY = compareOnY;
+function compareOnX(polygon1, polygon2) {
+    const sort = getMinXCoordinate(polygon1) - getMinXCoordinate(polygon2);
+    if (sort === 0) {
+        return 0;
+    }
+    return sort < 0 ? -1 : 1;
+}
+exports.compareOnX = compareOnX;

package/src/http/endpoint.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { RequestOptions } from "https";
+import { InputSource } from "../input";
+import { IncomingMessage, ClientRequest } from "http";
+import { PageOptions } from "../input";
+import { MindeeApi } from "./mindeeApi";
+export interface EndpointResponse {
+    messageObj: IncomingMessage;
+    data: {
+        [key: string]: any;
+    };
+}
+export declare class Endpoint {
+    #private;
+    urlName: string;
+    owner: string;
+    version: string;
+    urlRoot: string;
+    settings: MindeeApi;
+    constructor(urlName: string, owner: string, version: string, settings: MindeeApi);
+    predict(params: {
+        inputDoc: InputSource;
+        includeWords: boolean;
+        pageOptions?: PageOptions;
+        cropper: boolean;
+    }): Promise<EndpointResponse>;
+    predictAsync(params: {
+        inputDoc: InputSource;
+        includeWords: boolean;
+        pageOptions?: PageOptions;
+        cropper: boolean;
+    }): Promise<EndpointResponse>;
+    getQueuedDocument(queueId: string): Promise<EndpointResponse>;
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param predictUrl
+     * @param includeWords
+     * @param cropper
+     */
+    protected sendFileForPrediction(input: InputSource, predictUrl: string, includeWords?: boolean, cropper?: boolean): Promise<EndpointResponse>;
+    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
+}

package/src/http/endpoint.js

@@ -0,0 +1,188 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Endpoint_instances, _Endpoint_cutDocPages, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Endpoint = void 0;
+const https_1 = require("https");
+const url_1 = require("url");
+const form_data_1 = __importDefault(require("form-data"));
+const logger_1 = require("../logger");
+const base_1 = require("../input/base");
+const error_1 = require("./error");
+class Endpoint {
+    constructor(urlName, owner, version, settings) {
+        _Endpoint_instances.add(this);
+        this.owner = owner;
+        this.urlName = urlName;
+        this.version = version;
+        this.settings = settings;
+        this.urlRoot = `/v1/products/${owner}/${urlName}/v${version}`;
+    }
+    async predict(params) {
+        await params.inputDoc.init();
+        if (params.pageOptions !== undefined) {
+            await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_cutDocPages).call(this, params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.cropper);
+        const statusCode = response.messageObj.statusCode;
+        if (statusCode === undefined || statusCode > 400) {
+            (0, error_1.handleError)(this.urlName, response, statusCode);
+        }
+        return response;
+    }
+    async predictAsync(params) {
+        await params.inputDoc.init();
+        if (params.pageOptions !== undefined) {
+            await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_cutDocPages).call(this, params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.cropper);
+        const statusCode = response.messageObj.statusCode;
+        if (statusCode === undefined || statusCode > 400) {
+            (0, error_1.handleError)(this.urlName, response, statusCode);
+        }
+        return response;
+    }
+    async getQueuedDocument(queueId) {
+        const queueResponse = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentQueueReqGet).call(this, queueId);
+        const queueStatusCode = queueResponse.messageObj.statusCode;
+        if (queueStatusCode === undefined ||
+            queueStatusCode < 200 ||
+            queueStatusCode > 400) {
+            (0, error_1.handleError)(this.urlName, queueResponse, queueStatusCode);
+        }
+        if (queueStatusCode === 302 &&
+            queueResponse.messageObj.headers.location !== undefined) {
+            const docId = queueResponse.messageObj.headers.location.split("/").pop();
+            if (docId !== undefined) {
+                return await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, docId);
+            }
+        }
+        return queueResponse;
+    }
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param predictUrl
+     * @param includeWords
+     * @param cropper
+     */
+    sendFileForPrediction(input, predictUrl, includeWords = false, cropper = false) {
+        return new Promise((resolve, reject) => {
+            const searchParams = new url_1.URLSearchParams();
+            if (cropper) {
+                searchParams.append("cropper", "true");
+            }
+            const form = new form_data_1.default();
+            if (input instanceof base_1.LocalInputSource) {
+                if (input.fileObject instanceof Buffer) {
+                    form.append("document", input.fileObject, {
+                        filename: input.filename,
+                    });
+                }
+                else {
+                    form.append("document", input.fileObject);
+                }
+            }
+            if (includeWords) {
+                form.append("include_mvision", "true");
+            }
+            const headers = { ...this.settings.baseHeaders, ...form.getHeaders() };
+            let path = `${this.urlRoot}/${predictUrl}`;
+            if (searchParams.keys.length > 0) {
+                path += `?${searchParams}`;
+            }
+            const options = {
+                method: "POST",
+                headers: headers,
+                hostname: this.settings.hostname,
+                path: path,
+            };
+            const req = this.readResponse(options, resolve, reject);
+            form.pipe(req);
+            // potential ECONNRESET if we don't end the request.
+            req.end();
+        });
+    }
+    readResponse(options, resolve, reject) {
+        logger_1.logger.debug(`${options.method}: https://${options.hostname}${options.path}`);
+        const req = (0, https_1.request)(options, function (res) {
+            // when the encoding is set, data chunks will be strings
+            res.setEncoding("utf-8");
+            let responseBody = "";
+            res.on("data", function (chunk) {
+                logger_1.logger.debug("Receiving data ...");
+                responseBody += chunk;
+            });
+            res.on("end", function () {
+                logger_1.logger.debug("Parsing the response ...");
+                // handle empty responses from server, for example in the case of redirects
+                if (!responseBody) {
+                    responseBody = "{}";
+                }
+                try {
+                    const parsedResponse = JSON.parse(responseBody);
+                    try {
+                        resolve({
+                            messageObj: res,
+                            data: parsedResponse,
+                        });
+                    }
+                    catch (error) {
+                        logger_1.logger.error("Could not construct the return object.");
+                        reject(error);
+                    }
+                }
+                catch (error) {
+                    logger_1.logger.error("Could not parse the return as JSON.");
+                    logger_1.logger.debug(responseBody);
+                    reject(error);
+                }
+            });
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+        return req;
+    }
+}
+exports.Endpoint = Endpoint;
+_Endpoint_instances = new WeakSet(), _Endpoint_cutDocPages = async function _Endpoint_cutDocPages(inputDoc, pageOptions) {
+    if (inputDoc instanceof base_1.LocalInputSource && inputDoc.isPdf()) {
+        await inputDoc.cutPdf(pageOptions);
+    }
+}, _Endpoint_predictReqPost = function _Endpoint_predictReqPost(input, includeWords = false, cropper = false) {
+    return this.sendFileForPrediction(input, "predict", includeWords, cropper);
+}, _Endpoint_predictAsyncReqPost = function _Endpoint_predictAsyncReqPost(input, includeWords = false, cropper = false) {
+    return this.sendFileForPrediction(input, "predict_async", includeWords, cropper);
+}, _Endpoint_documentQueueReqGet = function _Endpoint_documentQueueReqGet(queueId) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: "GET",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: `${this.urlRoot}/documents/queue/${queueId}`,
+        };
+        const req = this.readResponse(options, resolve, reject);
+        // potential ECONNRESET if we don't end the request.
+        req.end();
+    });
+}, _Endpoint_documentGetReq = function _Endpoint_documentGetReq(documentId) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: "GET",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: `${this.urlRoot}/documents/${documentId}`,
+        };
+        const req = this.readResponse(options, resolve, reject);
+        // potential ECONNRESET if we don't end the request.
+        req.end();
+    });
+};

package/src/http/error.d.ts

@@ -0,0 +1,2 @@
+import { EndpointResponse } from "./endpoint";
+export declare function handleError(url: string, response: EndpointResponse, statusCode?: number): void;

package/src/http/error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = void 0;
+const handler_1 = require("../errors/handler");
+function handleError(url, response, statusCode) {
+    const errorMessage = JSON.stringify(response.data, null, 2);
+    handler_1.errorHandler.throw(new Error(`${url} API ${statusCode} HTTP error: ${errorMessage}`));
+}
+exports.handleError = handleError;

package/src/http/index.d.ts

@@ -0,0 +1,3 @@
+export { Endpoint, EndpointResponse } from "./endpoint";
+export { STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, MindeeApi, } from "./mindeeApi";
+export { handleError } from "./error";

package/src/http/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.MindeeApi = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.Endpoint = void 0;
+var endpoint_1 = require("./endpoint");
+Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
+var mindeeApi_1 = require("./mindeeApi");
+Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return mindeeApi_1.STANDARD_API_OWNER; } });
+Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return mindeeApi_1.API_KEY_ENVVAR_NAME; } });
+Object.defineProperty(exports, "MindeeApi", { enumerable: true, get: function () { return mindeeApi_1.MindeeApi; } });
+var error_1 = require("./error");
+Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return error_1.handleError; } });

package/src/http/mindeeApi.d.ts

@@ -0,0 +1,20 @@
+export declare const API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
+export declare const API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
+export declare const STANDARD_API_OWNER = "mindee";
+interface MindeeApiConstructorProps {
+    apiKey: string;
+    urlName: string;
+    version: string;
+    owner: string;
+}
+export declare class MindeeApi {
+    apiKey: string;
+    baseHeaders: Record<string, string>;
+    hostname: string;
+    private readonly urlName;
+    private readonly version;
+    constructor({ apiKey, urlName, version, owner, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}
+export {};

package/src/http/mindeeApi.js

@@ -0,0 +1,73 @@
+"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.MindeeApi = exports.STANDARD_API_OWNER = exports.API_HOST_ENVVAR_NAME = exports.API_KEY_ENVVAR_NAME = void 0;
+const logger_1 = require("../logger");
+const package_json_1 = require("../../package.json");
+const os = __importStar(require("os"));
+exports.API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
+exports.API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
+exports.STANDARD_API_OWNER = "mindee";
+const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
+const USER_AGENT = `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${os.type().toLowerCase()}`;
+class MindeeApi {
+    constructor({ apiKey = "", urlName, version, owner, }) {
+        if (!apiKey || apiKey.length === 0) {
+            if (!process.env[exports.API_KEY_ENVVAR_NAME] ||
+                process.env[exports.API_KEY_ENVVAR_NAME].length === 0) {
+                throw new Error(`Missing API key for ${urlName} v${version} (belonging to ${owner}) check your Client Configuration.
+You can set this using the ${exports.API_KEY_ENVVAR_NAME} environment variable.`);
+            }
+            this.apiKey = process.env[exports.API_KEY_ENVVAR_NAME];
+        }
+        else {
+            this.apiKey = apiKey;
+        }
+        this.baseHeaders = {
+            "User-Agent": USER_AGENT,
+            Authorization: `Token ${this.apiKey}`,
+        };
+        this.hostname = this.hostnameFromEnv();
+        this.urlName = urlName;
+        this.version = version;
+    }
+    apiKeyFromEnv() {
+        const envVarValue = process.env[exports.API_KEY_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set ${this.urlName} v${this.version} API key from environment: ${exports.API_KEY_ENVVAR_NAME}`);
+            return envVarValue;
+        }
+        return "";
+    }
+    hostnameFromEnv() {
+        const envVarValue = process.env[exports.API_HOST_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set the API hostname to ${envVarValue}`);
+            return envVarValue;
+        }
+        return DEFAULT_MINDEE_API_HOST;
+    }
+}
+exports.MindeeApi = MindeeApi;

package/src/index.d.ts

@@ -1,4 +1,4 @@
-export { CustomV1, Document, FinancialDocumentV0, FinancialDocumentV1, InvoiceV3, InvoiceV4, InvoiceSplitterV1, PassportV1, ReceiptV3, ReceiptV4, ReceiptV5, CropperV1, MindeeVisionV1, ProofOfAddressV1, fr, us, eu, } from "./documents";
-export { Client, ClientOptions, CustomConfigParams, DocumentClient, PredictOptions, } from "./client";
-export { ResponseSig, Response, AsyncPredictResponse } from "./api";
-export { InputSource, PageOptionsOperation } from "./inputs";
+export * as product from "./product";
+export { Client, CustomConfigParams, PredictOptions } from "./client";
+export { AsyncPredictResponse, PredictResponse, Document, Page, } from "./parsing/common";
+export { InputSource, PageOptionsOperation } from "./input";

package/src/index.js

@@ -1,30 +1,37 @@
 "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.PageOptionsOperation = exports.InputSource = exports.AsyncPredictResponse = exports.Response = exports.DocumentClient = exports.Client = exports.eu = exports.us = exports.fr = exports.ProofOfAddressV1 = exports.MindeeVisionV1 = exports.CropperV1 = exports.ReceiptV5 = exports.ReceiptV4 = exports.ReceiptV3 = exports.PassportV1 = exports.InvoiceSplitterV1 = exports.InvoiceV4 = exports.InvoiceV3 = exports.FinancialDocumentV1 = exports.FinancialDocumentV0 = exports.Document = exports.CustomV1 = void 0;
-var documents_1 = require("./documents");
-Object.defineProperty(exports, "CustomV1", { enumerable: true, get: function () { return documents_1.CustomV1; } });
-Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return documents_1.Document; } });
-Object.defineProperty(exports, "FinancialDocumentV0", { enumerable: true, get: function () { return documents_1.FinancialDocumentV0; } });
-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, "InvoiceV4", { enumerable: true, get: function () { return documents_1.InvoiceV4; } });
-Object.defineProperty(exports, "InvoiceSplitterV1", { enumerable: true, get: function () { return documents_1.InvoiceSplitterV1; } });
-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, "ReceiptV5", { enumerable: true, get: function () { return documents_1.ReceiptV5; } });
-Object.defineProperty(exports, "CropperV1", { enumerable: true, get: function () { return documents_1.CropperV1; } });
-Object.defineProperty(exports, "MindeeVisionV1", { enumerable: true, get: function () { return documents_1.MindeeVisionV1; } });
-Object.defineProperty(exports, "ProofOfAddressV1", { enumerable: true, get: function () { return documents_1.ProofOfAddressV1; } });
-Object.defineProperty(exports, "fr", { enumerable: true, get: function () { return documents_1.fr; } });
-Object.defineProperty(exports, "us", { enumerable: true, get: function () { return documents_1.us; } });
-Object.defineProperty(exports, "eu", { enumerable: true, get: function () { return documents_1.eu; } });
+exports.PageOptionsOperation = exports.InputSource = exports.Page = exports.Document = exports.PredictResponse = exports.AsyncPredictResponse = exports.Client = exports.product = void 0;
+exports.product = __importStar(require("./product"));
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
-Object.defineProperty(exports, "DocumentClient", { enumerable: true, get: function () { return client_1.DocumentClient; } });
-var api_1 = require("./api");
-Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return api_1.Response; } });
-Object.defineProperty(exports, "AsyncPredictResponse", { enumerable: true, get: function () { return api_1.AsyncPredictResponse; } });
-var inputs_1 = require("./inputs");
-Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return inputs_1.InputSource; } });
-Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return inputs_1.PageOptionsOperation; } });
+var common_1 = require("./parsing/common");
+Object.defineProperty(exports, "AsyncPredictResponse", { enumerable: true, get: function () { return common_1.AsyncPredictResponse; } });
+Object.defineProperty(exports, "PredictResponse", { enumerable: true, get: function () { return common_1.PredictResponse; } });
+Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return common_1.Document; } });
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return common_1.Page; } });
+var input_1 = require("./input");
+Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return input_1.InputSource; } });
+Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return input_1.PageOptionsOperation; } });

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

@@ -7,9 +7,11 @@ 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 const INPUT_TYPE_BUFFER = "buffer";
-export declare class InputSource {
+export declare abstract class InputSource {
+    init(): Promise<void>;
+}
+export declare abstract class LocalInputSource extends InputSource {
     inputType: string;
     filename: string;
     filepath?: string;
@@ -22,7 +24,6 @@ export declare class InputSource {
      * NB: Because of async calls, init() should be called after creating the object
      */
     constructor({ inputType }: InputProps);
-    init(): Promise<void>;
     isPdf(): boolean;
     checkMimetype(): Promise<string>;
     /**