mindee 4.36.2 → 5.0.0-alpha1

package/src/v1/client.js

@@ -0,0 +1,277 @@
+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 _Client_instances, _Client_setAsyncParams, _Client_buildProductEndpoint, _Client_initializeOTSEndpoint, _Client_getOtsEndpoint;
+import { setTimeout } from "node:timers/promises";
+import { errorHandler } from "../errors/handler.js";
+import { LOG_LEVELS, logger } from "../logger.js";
+import { ApiSettingsV1, Endpoint, STANDARD_API_OWNER, } from "./http/index.js";
+import { AsyncPredictResponse, FeedbackResponse, PredictResponse, WorkflowResponse, } from "./parsing/common/index.js";
+import { InferenceFactory } from "./parsing/common/inference.js";
+import { GeneratedV1 } from "./product/index.js";
+import { WorkflowEndpoint } from "./http/index.js";
+/**
+ * Mindee Client class that centralizes most basic operations.
+ *
+ * @category Client
+ */
+export class Client {
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, throwOnError, debug, dispatcher } = {
+        apiKey: undefined,
+        throwOnError: true,
+        debug: false,
+        dispatcher: undefined,
+    }) {
+        _Client_instances.add(this);
+        this.apiSettings = new ApiSettingsV1({
+            apiKey: apiKey,
+            dispatcher: dispatcher,
+        });
+        errorHandler.throwOnError = throwOnError ?? true;
+        logger.level = debug ?? process.env.MINDEE_DEBUG
+            ? LOG_LEVELS["debug"]
+            : LOG_LEVELS["warn"];
+        logger.debug("Client V1 Initialized");
+    }
+    /**
+     * Send a document to a synchronous endpoint and parse the predictions.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource file to parse.
+     * @param params parameters relating to prediction options.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async parse(productClass, inputSource, params = {
+        endpoint: undefined,
+        allWords: undefined,
+        fullText: undefined,
+        cropper: undefined,
+        pageOptions: undefined,
+    }) {
+        const endpoint = params?.endpoint ?? __classPrivateFieldGet(this, _Client_instances, "m", _Client_initializeOTSEndpoint).call(this, productClass);
+        if (inputSource === undefined) {
+            throw new Error("The 'parse' function requires an input document.");
+        }
+        const rawPrediction = await endpoint.predict({
+            inputDoc: inputSource,
+            includeWords: this.getBooleanParam(params.allWords),
+            fullText: this.getBooleanParam(params.fullText),
+            pageOptions: params.pageOptions,
+            cropper: this.getBooleanParam(params.cropper),
+        });
+        return new PredictResponse(productClass, rawPrediction.data);
+    }
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource file to parse.
+     * @param params parameters relating to prediction options.
+     * @category Asynchronous
+     * @returns a `Promise` containing the job (queue) corresponding to a document.
+     */
+    async enqueue(productClass, inputSource, params = {}) {
+        const endpoint = params?.endpoint ?? __classPrivateFieldGet(this, _Client_instances, "m", _Client_initializeOTSEndpoint).call(this, productClass);
+        if (inputSource === undefined) {
+            throw new Error("The 'enqueue' function requires an input document.");
+        }
+        const rawResponse = await endpoint.predictAsync({
+            inputDoc: inputSource,
+            includeWords: this.getBooleanParam(params.allWords),
+            fullText: this.getBooleanParam(params.fullText),
+            pageOptions: params?.pageOptions,
+            cropper: this.getBooleanParam(params.cropper),
+            rag: this.getBooleanParam(params.rag),
+            workflowId: params.workflowId
+        });
+        return new AsyncPredictResponse(productClass, rawResponse.data);
+    }
+    /**
+     * Polls a queue and returns its status as well as the prediction results if the parsing is done.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param queueId id of the queue to poll.
+     * @param params parameters relating to prediction options.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    async parseQueued(productClass, queueId, params = {}) {
+        const endpoint = params?.endpoint ?? __classPrivateFieldGet(this, _Client_instances, "m", _Client_initializeOTSEndpoint).call(this, productClass);
+        const docResponse = await endpoint.getQueuedDocument(queueId);
+        return new AsyncPredictResponse(productClass, docResponse.data);
+    }
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @param inputSource file to send to the API.
+     * @param workflowId ID of the workflow.
+     * @param params parameters relating to prediction options.
+     * @category Workflow
+     * @returns a `Promise` containing the job (queue) corresponding to a document.
+     */
+    async executeWorkflow(inputSource, workflowId, params = {}) {
+        const workflowEndpoint = new WorkflowEndpoint(this.apiSettings, workflowId);
+        if (inputSource === undefined) {
+            throw new Error("The 'executeWorkflow' function requires an input document.");
+        }
+        const rawResponse = await workflowEndpoint.executeWorkflow({
+            inputDoc: inputSource,
+            alias: params.alias,
+            priority: params.priority,
+            pageOptions: params?.pageOptions,
+            fullText: this.getBooleanParam(params.fullText),
+        });
+        return new WorkflowResponse(GeneratedV1, rawResponse.data);
+    }
+    /**
+     * Fetch prediction results from a document already processed.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param documentId id of the document to fetch.
+     * @param params optional parameters.
+     * @param params.endpoint Endpoint, only specify if using a custom product.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async getDocument(productClass, documentId, params = {}) {
+        const endpoint = params?.endpoint ?? __classPrivateFieldGet(this, _Client_instances, "m", _Client_initializeOTSEndpoint).call(this, productClass);
+        const response = await endpoint.getDocument(documentId);
+        return new PredictResponse(productClass, response.data);
+    }
+    /**
+     * Send feedback for a document.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param documentId id of the document to send feedback for.
+     * @param feedback the feedback to send.
+     * @param params optional parameters.
+     * @param params.endpoint Endpoint, only specify if using a custom product.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing feedback results.
+     */
+    async sendFeedback(productClass, documentId, feedback, params = {}) {
+        const endpoint = params?.endpoint ?? __classPrivateFieldGet(this, _Client_instances, "m", _Client_initializeOTSEndpoint).call(this, productClass);
+        const response = await endpoint.sendFeedback(documentId, feedback);
+        return new FeedbackResponse(response.data);
+    }
+    /**
+     * Send a document to an asynchronous endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource document to parse.
+     * @param asyncParams parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async enqueueAndParse(productClass, inputSource, asyncParams = {
+        endpoint: undefined,
+        allWords: undefined,
+        fullText: undefined,
+        cropper: undefined,
+        pageOptions: undefined,
+        initialDelaySec: 2,
+        delaySec: 1.5,
+        maxRetries: 80,
+        initialTimerOptions: undefined,
+        recurringTimerOptions: undefined,
+    }) {
+        const validatedAsyncParams = __classPrivateFieldGet(this, _Client_instances, "m", _Client_setAsyncParams).call(this, asyncParams);
+        const enqueueResponse = await this.enqueue(productClass, inputSource, validatedAsyncParams);
+        if (enqueueResponse.job.id === undefined || enqueueResponse.job.id.length === 0) {
+            throw Error("Enqueueing of the document failed.");
+        }
+        const queueId = enqueueResponse.job.id;
+        logger.debug(`Successfully enqueued document with job id: ${queueId}.`);
+        await setTimeout(validatedAsyncParams.initialDelaySec * 1000, undefined, validatedAsyncParams.initialTimerOptions);
+        let retryCounter = 1;
+        let pollResults;
+        pollResults = await this.parseQueued(productClass, queueId, validatedAsyncParams);
+        while (retryCounter < validatedAsyncParams.maxRetries) {
+            logger.debug(`Polling server for parsing result with queueId: ${queueId}.
+Attempt n°${retryCounter}/${validatedAsyncParams.maxRetries}.
+Job status: ${pollResults.job.status}.`);
+            if (pollResults.job.status === "completed") {
+                break;
+            }
+            await setTimeout(validatedAsyncParams.delaySec * 1000, undefined, validatedAsyncParams.recurringTimerOptions);
+            pollResults = await this.parseQueued(productClass, queueId, validatedAsyncParams);
+            retryCounter++;
+        }
+        if (pollResults.job.status !== "completed") {
+            throw Error("Asynchronous parsing request timed out after " +
+                validatedAsyncParams.delaySec * retryCounter +
+                " seconds");
+        }
+        return pollResults;
+    }
+    /**
+     * Forces boolean coercion on truthy/falsy parameters.
+     * @param param input parameter to check.
+     * @returns a strict boolean value.
+     */
+    getBooleanParam(param) {
+        return param !== undefined ? param : false;
+    }
+    /**
+     * Creates a custom endpoint with the given values. Raises an error if the endpoint is invalid.
+     * @param endpointName Name of the custom Endpoint.
+     * @param accountName Name of the account tied to the Endpoint.
+     * @param endpointVersion Version of the custom Endpoint.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     *
+     * @returns Endpoint a new product endpoint
+     */
+    createEndpoint(endpointName, accountName, endpointVersion) {
+        if (!endpointName || endpointName.length === 0) {
+            throw new Error("Missing parameter 'endpointName' for custom build!");
+        }
+        let cleanEndpointVersion;
+        if (!endpointVersion || endpointVersion.length === 0) {
+            logger.debug("No version provided for a custom build, will poll using version 1 by default.");
+            cleanEndpointVersion = "1";
+        }
+        else {
+            cleanEndpointVersion = endpointVersion;
+        }
+        return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildProductEndpoint).call(this, endpointName, accountName, cleanEndpointVersion);
+    }
+}
+_Client_instances = new WeakSet(), _Client_setAsyncParams = function _Client_setAsyncParams(asyncParams) {
+    const minDelaySec = 1;
+    const minInitialDelay = 1;
+    const minRetries = 2;
+    const newAsyncParams = { ...asyncParams };
+    newAsyncParams.delaySec ?? (newAsyncParams.delaySec = 1.5);
+    newAsyncParams.initialDelaySec ?? (newAsyncParams.initialDelaySec = 2);
+    newAsyncParams.maxRetries ?? (newAsyncParams.maxRetries = 80);
+    if (newAsyncParams.delaySec < minDelaySec) {
+        throw Error(`Cannot set auto-parsing delay to less than ${minDelaySec} second(s).`);
+    }
+    if (newAsyncParams.initialDelaySec < minInitialDelay) {
+        throw Error(`Cannot set initial parsing delay to less than ${minInitialDelay} second(s).`);
+    }
+    if (newAsyncParams.maxRetries < minRetries) {
+        throw Error(`Cannot set retry to less than ${minRetries}.`);
+    }
+    return newAsyncParams;
+}, _Client_buildProductEndpoint = function _Client_buildProductEndpoint(endpointName, accountName, endpointVersion) {
+    return new Endpoint(endpointName, accountName, endpointVersion, this.apiSettings);
+}, _Client_initializeOTSEndpoint = function _Client_initializeOTSEndpoint(productClass) {
+    const [endpointName, endpointVersion] = __classPrivateFieldGet(this, _Client_instances, "m", _Client_getOtsEndpoint).call(this, productClass);
+    return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildProductEndpoint).call(this, endpointName, STANDARD_API_OWNER, endpointVersion);
+}, _Client_getOtsEndpoint = function _Client_getOtsEndpoint(productClass) {
+    const [endpointName, endpointVersion] = InferenceFactory.getEndpoint(productClass);
+    return [endpointName, endpointVersion];
+};

package/src/v1/extraction/index.d.ts

@@ -0,0 +1,2 @@
+export { extractReceipts, ExtractedMultiReceiptImage } from "./multiReceiptsExtractor/index.js";
+export { extractInvoices, ExtractedInvoiceSplitterImage } from "./invoiceSplitterExtractor/index.js";

package/src/v1/extraction/index.js

@@ -0,0 +1,2 @@
+export { extractReceipts, ExtractedMultiReceiptImage } from "./multiReceiptsExtractor/index.js";
+export { extractInvoices, ExtractedInvoiceSplitterImage } from "./invoiceSplitterExtractor/index.js";

package/src/v1/extraction/invoiceSplitterExtractor/extractedInvoiceSplitterImage.d.ts

@@ -0,0 +1,9 @@
+import { ExtractedImage } from "../../../image/extractedImage.js";
+/**
+ * Wrapper class for extracted invoice pages.
+ */
+export declare class ExtractedInvoiceSplitterImage extends ExtractedImage {
+    readonly pageIdMin: number;
+    readonly pageIdMax: number;
+    constructor(buffer: Uint8Array, pageIndices: [number, number]);
+}

package/src/v1/extraction/invoiceSplitterExtractor/extractedInvoiceSplitterImage.js

@@ -0,0 +1,11 @@
+import { ExtractedImage } from "../../../image/extractedImage.js";
+/**
+ * Wrapper class for extracted invoice pages.
+ */
+export class ExtractedInvoiceSplitterImage extends ExtractedImage {
+    constructor(buffer, pageIndices) {
+        super(buffer, `invoice_p_${pageIndices[0]}-${pageIndices[1]}.pdf`);
+        this.pageIdMin = pageIndices[0];
+        this.pageIdMax = pageIndices[1];
+    }
+}

package/src/v1/extraction/invoiceSplitterExtractor/index.d.ts

@@ -0,0 +1,2 @@
+export { extractInvoices } from "./invoiceSplitterExtractor.js";
+export { ExtractedInvoiceSplitterImage } from "./extractedInvoiceSplitterImage.js";

package/src/v1/extraction/invoiceSplitterExtractor/index.js

@@ -0,0 +1,2 @@
+export { extractInvoices } from "./invoiceSplitterExtractor.js";
+export { ExtractedInvoiceSplitterImage } from "./extractedInvoiceSplitterImage.js";

package/src/v1/extraction/invoiceSplitterExtractor/invoiceSplitterExtractor.d.ts

@@ -0,0 +1,13 @@
+import { InvoiceSplitterV1 } from "../../../v1/product/index.js";
+import { LocalInputSource } from "../../../input/index.js";
+import { ExtractedInvoiceSplitterImage } from "../../../v1/extraction/index.js";
+/**
+ * Extracts & cuts the pages of a main document invoice according to the provided indexes.
+ *
+ * @param inputFile File to extract sub-invoices from.
+ * @param indexes List of indexes to cut the document according to.
+ *  Can be provided either as a InvoiceSplitterV1 inference, or a direct list of splits.
+ * @param strict If set to true, doesn't cut pages where the API isn't 100% confident.
+ * @returns A promise of extracted images, as an array of ExtractedInvoiceSplitterImage.
+ */
+export declare function extractInvoices(inputFile: LocalInputSource, indexes: InvoiceSplitterV1 | number[][], strict?: boolean): Promise<ExtractedInvoiceSplitterImage[]>;

package/src/v1/extraction/invoiceSplitterExtractor/invoiceSplitterExtractor.js

@@ -0,0 +1,83 @@
+import { MindeeError, MindeeInputSourceError } from "../../../errors/index.js";
+import { InvoiceSplitterV1 } from "../../../v1/product/index.js";
+import { ExtractedInvoiceSplitterImage } from "../../../v1/extraction/index.js";
+import { loadOptionalDependency } from "../../../dependency/index.js";
+let pdfLib = null;
+async function getPdfLib() {
+    if (!pdfLib) {
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        pdfLib = pdfLibImport.default || pdfLibImport;
+    }
+    return pdfLib;
+}
+async function splitPdf(pdfDoc, invoicePageGroups) {
+    const pdfLib = await getPdfLib();
+    if (invoicePageGroups.length === 0) {
+        return [];
+    }
+    const generatedPdfs = [];
+    for (let i = 0; i < invoicePageGroups.length; i++) {
+        const subdocument = await pdfLib.PDFDocument.create();
+        const fullIndexes = [];
+        for (let j = invoicePageGroups[i][0]; j <= invoicePageGroups[i][invoicePageGroups[i].length - 1]; j++) {
+            fullIndexes.push(j);
+        }
+        const copiedPages = await subdocument.copyPages(pdfDoc, fullIndexes);
+        copiedPages.map((page) => {
+            subdocument.addPage(page);
+        });
+        const subdocumentBytes = await subdocument.save();
+        generatedPdfs.push(new ExtractedInvoiceSplitterImage(subdocumentBytes, [invoicePageGroups[i][0], invoicePageGroups[i][invoicePageGroups[i].length - 1]]));
+    }
+    return generatedPdfs;
+}
+async function getPdfDoc(inputFile) {
+    const pdfLib = await getPdfLib();
+    await inputFile.init();
+    if (!inputFile.isPdf()) {
+        throw new MindeeInputSourceError("Invoice Splitter is only compatible with PDF documents.");
+    }
+    const pdfDoc = await pdfLib.PDFDocument.load(inputFile.fileObject, {
+        ignoreEncryption: true,
+        password: ""
+    });
+    if (pdfDoc.getPageCount() < 2) {
+        throw new MindeeInputSourceError("Invoice Splitter is only compatible with multi-page PDF documents.");
+    }
+    return pdfDoc;
+}
+/**
+ * Extracts & cuts the pages of a main document invoice according to the provided indexes.
+ *
+ * @param inputFile File to extract sub-invoices from.
+ * @param indexes List of indexes to cut the document according to.
+ *  Can be provided either as a InvoiceSplitterV1 inference, or a direct list of splits.
+ * @param strict If set to true, doesn't cut pages where the API isn't 100% confident.
+ * @returns A promise of extracted images, as an array of ExtractedInvoiceSplitterImage.
+ */
+export async function extractInvoices(inputFile, indexes, strict = false) {
+    if (!indexes) {
+        throw new MindeeError("No possible receipts candidates found for MultiReceipts extraction.");
+    }
+    let customIndexes = [];
+    if (indexes instanceof InvoiceSplitterV1) {
+        indexes.prediction.invoicePageGroups.map((invoicePageGroup) => {
+            if (!strict || invoicePageGroup.confidence === 1) {
+                customIndexes.push(invoicePageGroup.pageIndexes ?? []);
+            }
+        });
+    }
+    else {
+        customIndexes = indexes;
+    }
+    const pdfDoc = await getPdfDoc(inputFile);
+    const pageCount = pdfDoc.getPageCount();
+    customIndexes.forEach((pageGroup) => {
+        pageGroup.forEach((index) => {
+            if (index >= pageCount) {
+                throw new MindeeError(`Given index ${index} doesn't exist in page range (0-${pageCount - 1})`);
+            }
+        });
+    });
+    return await splitPdf(pdfDoc, customIndexes);
+}

package/src/v1/extraction/multiReceiptsExtractor/extractedMultiReceiptImage.d.ts

@@ -0,0 +1,9 @@
+import { ExtractedImage } from "../../../image/index.js";
+/**
+ * Wrapper class for extracted multiple-receipts images.
+ */
+export declare class ExtractedMultiReceiptImage extends ExtractedImage {
+    readonly receiptId: number;
+    readonly pageId: number;
+    constructor(buffer: Uint8Array, pageId: number, receiptId: number);
+}

package/src/v1/extraction/multiReceiptsExtractor/extractedMultiReceiptImage.js

@@ -0,0 +1,11 @@
+import { ExtractedImage } from "../../../image/index.js";
+/**
+ * Wrapper class for extracted multiple-receipts images.
+ */
+export class ExtractedMultiReceiptImage extends ExtractedImage {
+    constructor(buffer, pageId, receiptId) {
+        super(buffer, `receipt_p${pageId}_${receiptId}.pdf`);
+        this.pageId = pageId;
+        this.receiptId = receiptId;
+    }
+}

package/src/v1/extraction/multiReceiptsExtractor/index.d.ts

@@ -0,0 +1,2 @@
+export { extractReceipts } from "./multiReceiptsExtractor.js";
+export { ExtractedMultiReceiptImage } from "./extractedMultiReceiptImage.js";

package/src/v1/extraction/multiReceiptsExtractor/index.js

@@ -0,0 +1,2 @@
+export { extractReceipts } from "./multiReceiptsExtractor.js";
+export { ExtractedMultiReceiptImage } from "./extractedMultiReceiptImage.js";

package/src/v1/extraction/multiReceiptsExtractor/multiReceiptsExtractor.d.ts

@@ -0,0 +1,11 @@
+import { MultiReceiptsDetectorV1 } from "../../../v1/product/index.js";
+import { ExtractedMultiReceiptImage } from "../../../v1/extraction/index.js";
+import { LocalInputSource } from "../../../input/index.js";
+/**
+ * Extracts individual receipts from multi-receipts documents.
+ *
+ * @param inputFile File to extract sub-receipts from.
+ * @param inference Results of the inference.
+ * @returns Individual extracted receipts as an array of ExtractedMultiReceiptImage.
+ */
+export declare function extractReceipts(inputFile: LocalInputSource, inference: MultiReceiptsDetectorV1): Promise<ExtractedMultiReceiptImage[]>;

package/src/v1/extraction/multiReceiptsExtractor/multiReceiptsExtractor.js

@@ -0,0 +1,81 @@
+import { MindeeError, MindeeInputSourceError } from "../../../errors/index.js";
+import { ExtractedMultiReceiptImage } from "../../../v1/extraction/index.js";
+import { extractFromPage } from "../../../image/index.js";
+import { loadOptionalDependency } from "../../../dependency/index.js";
+let pdfLib = null;
+async function getPdfLib() {
+    if (!pdfLib) {
+        const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
+        pdfLib = pdfLibImport.default || pdfLibImport;
+    }
+    return pdfLib;
+}
+/**
+ * Given a page and a set of coordinates, extracts & assigns individual receipts to an ExtractedMultiReceiptImage
+ * object.
+ *
+ * @param pdfPage PDF Page to extract from.
+ * @param boundingBoxes A set of coordinates delimiting the position of each receipt.
+ * @param pageId Id of the page the receipt is extracted from. Caution: this starts at 0, unlike the numbering in PDF
+ * pages.
+ */
+async function extractReceiptsFromPage(pdfPage, boundingBoxes, pageId) {
+    const extractedReceiptsRaw = await extractFromPage(pdfPage, boundingBoxes);
+    const extractedReceipts = [];
+    for (let i = 0; i < extractedReceiptsRaw.length; i++) {
+        extractedReceipts.push(new ExtractedMultiReceiptImage(extractedReceiptsRaw[i], pageId, i));
+    }
+    return extractedReceipts;
+}
+async function loadPdfDoc(inputFile) {
+    const pdfLib = await getPdfLib();
+    let pdfDoc;
+    if (!["image/jpeg", "image/jpg", "image/png", "application/pdf"].includes(inputFile.mimeType)) {
+        throw new MindeeInputSourceError('Unsupported file type "' +
+            inputFile.mimeType +
+            '" Currently supported types are .png, .jpg and .pdf');
+    }
+    else if (inputFile.isPdf()) {
+        pdfDoc = await pdfLib.PDFDocument.load(inputFile.fileObject, {
+            ignoreEncryption: true,
+            password: ""
+        });
+    }
+    else {
+        pdfDoc = await pdfLib.PDFDocument.create();
+        let image;
+        if (inputFile.mimeType === "image/png") {
+            image = await pdfDoc.embedPng(inputFile.fileObject);
+        }
+        else {
+            image = await pdfDoc.embedJpg(inputFile.fileObject);
+        }
+        const imageDims = image.scale(1);
+        const pageImage = pdfDoc.addPage([imageDims.width, imageDims.height]);
+        pageImage.drawImage(image);
+    }
+    return pdfDoc;
+}
+/**
+ * Extracts individual receipts from multi-receipts documents.
+ *
+ * @param inputFile File to extract sub-receipts from.
+ * @param inference Results of the inference.
+ * @returns Individual extracted receipts as an array of ExtractedMultiReceiptImage.
+ */
+export async function extractReceipts(inputFile, inference) {
+    const pdfLib = await getPdfLib();
+    const images = [];
+    if (!inference.prediction.receipts) {
+        throw new MindeeError("No possible receipts candidates found for MultiReceipts extraction.");
+    }
+    const pdfDoc = await loadPdfDoc(inputFile);
+    for (let pageId = 0; pageId < pdfDoc.getPageCount(); pageId++) {
+        const [page] = await pdfDoc.copyPages(pdfDoc, [pageId]);
+        page.setRotation(pdfLib.degrees(inference.pages[pageId].orientation?.value ?? 0));
+        const receiptPositions = inference.pages[pageId].prediction.receipts.map((receipt) => receipt.boundingBox);
+        const extractedReceipts = await extractReceiptsFromPage(page, receiptPositions, pageId);
+        images.push(...extractedReceipts);
+    }
+    return images;
+}

package/src/v1/http/apiSettingsV1.d.ts

@@ -0,0 +1,8 @@
+import { BaseSettings, MindeeApiConstructorProps } from "../../http/baseSettings.js";
+export declare const STANDARD_API_OWNER: string;
+export declare class ApiSettingsV1 extends BaseSettings {
+    baseHeaders: Record<string, string>;
+    constructor({ apiKey, dispatcher, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}

package/src/v1/http/apiSettingsV1.js

@@ -0,0 +1,37 @@
+import { logger } from "../../logger.js";
+import { BaseSettings } from "../../http/baseSettings.js";
+import { MindeeConfigurationError } from "../../errors/index.js";
+export const STANDARD_API_OWNER = "mindee";
+const API_V1_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
+const API_V1_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
+const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
+export class ApiSettingsV1 extends BaseSettings {
+    constructor({ apiKey, dispatcher, }) {
+        super(apiKey, dispatcher);
+        if (!this.apiKey || this.apiKey.length === 0) {
+            throw new MindeeConfigurationError("Your V1 API key could not be set, check your Client Configuration\n."
+                + `You can set this using the ${API_V1_KEY_ENVVAR_NAME} environment variable.`);
+        }
+        /* eslint-disable @typescript-eslint/naming-convention */
+        this.baseHeaders = {
+            "User-Agent": this.getUserAgent(),
+            Authorization: `Token ${this.apiKey}`,
+        };
+    }
+    apiKeyFromEnv() {
+        const envVarValue = process.env[API_V1_KEY_ENVVAR_NAME];
+        if (envVarValue) {
+            logger.debug("Set the V1 API key from the environment");
+            return envVarValue;
+        }
+        return "";
+    }
+    hostnameFromEnv() {
+        const envVarValue = process.env[API_V1_HOST_ENVVAR_NAME];
+        if (envVarValue) {
+            logger.debug(`Set the V1 API hostname from the environment to: ${envVarValue}`);
+            return envVarValue;
+        }
+        return DEFAULT_MINDEE_API_HOST;
+    }
+}

package/src/v1/http/endpoint.d.ts

@@ -0,0 +1,69 @@
+import { InputSource } from "../../input/index.js";
+import { StringDict } from "../../parsing/stringDict.js";
+import { BaseHttpResponse } from "../../http/apiCore.js";
+import { ApiSettingsV1 } from "./apiSettingsV1.js";
+import { PredictParams } from "./httpParams.js";
+/**
+ * Endpoint for a product (OTS or Custom).
+ */
+export declare class Endpoint {
+    #private;
+    /** Settings relating to the API. */
+    settings: ApiSettingsV1;
+    /** Root of the URL for API calls. */
+    urlRoot: string;
+    /** URL of a product. */
+    urlName: string;
+    /** Account owning the product. */
+    owner: string;
+    /** Product's version, as a string. */
+    version: string;
+    constructor(urlName: string, owner: string, version: string, settings: ApiSettingsV1);
+    /**
+     * Sends a document to the API and parses out the result.
+     * Throws an error if the server's response contains one.
+     * @param {PredictParams} params parameters relating to prediction options.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    predict(params: PredictParams): Promise<BaseHttpResponse>;
+    /**
+     * Enqueues a prediction to the API.
+     * Throws an error if the server's response contains one.
+     * @param {PredictParams} params parameters relating to prediction options.
+     * @category Asynchronous
+     * @returns a `Promise` containing queue data.
+     */
+    predictAsync(params: PredictParams): Promise<BaseHttpResponse>;
+    private extractStatusMessage;
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param queueId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing the parsed result.
+     */
+    getQueuedDocument(queueId: string): Promise<BaseHttpResponse>;
+    /**
+     * Send a feedback
+     * @param {string} documentId
+     */
+    getDocument(documentId: string): Promise<BaseHttpResponse>;
+    /**
+     * Send a feedback
+     * @param {string} documentId - ID of the document to send feedback to.
+     * @param {StringDict} feedback - Feedback object to send.
+     */
+    sendFeedback(documentId: string, feedback: StringDict): Promise<BaseHttpResponse>;
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param predictUrl
+     * @param includeWords
+     * @param fullText
+     * @param cropper
+     * @param rag
+     * @param workflowId
+     */
+    protected sendFileForPrediction(input: InputSource, predictUrl: string, includeWords?: boolean, fullText?: boolean, cropper?: boolean, rag?: boolean, workflowId?: string | undefined): Promise<BaseHttpResponse>;
+}