mindee 4.36.3 → 5.0.0-alpha1

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>;
+}

package/src/v1/http/endpoint.js

@@ -0,0 +1,229 @@
+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 _Endpoint_instances, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq, _Endpoint_documentFeedbackPutReq;
+import { URLSearchParams } from "url";
+import { LocalInputSource } from "../../input/index.js";
+import { cutDocPages, sendRequestAndReadResponse } from "../../http/apiCore.js";
+import { handleError } from "./errors.js";
+import { isValidAsyncResponse, isValidSyncResponse } from "./responseValidation.js";
+/**
+ * Endpoint for a product (OTS or Custom).
+ */
+export class Endpoint {
+    constructor(urlName, owner, version, settings) {
+        _Endpoint_instances.add(this);
+        this.settings = settings;
+        this.urlRoot = `/v1/products/${owner}/${urlName}/v${version}`;
+        this.owner = owner;
+        this.urlName = urlName;
+        this.version = version;
+    }
+    /**
+     * 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.
+     */
+    async predict(params) {
+        await params.inputDoc.init();
+        if (params.pageOptions !== undefined) {
+            await cutDocPages(params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper);
+        if (!isValidSyncResponse(response)) {
+            handleError(this.urlName, response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    /**
+     * 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.
+     */
+    async predictAsync(params) {
+        await params.inputDoc.init();
+        if (params.pageOptions !== undefined) {
+            await cutDocPages(params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper, params.rag, params.workflowId);
+        if (!isValidAsyncResponse(response)) {
+            handleError(this.urlName, response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    extractStatusMessage(response) {
+        if (response.messageObj?.statusMessage !== undefined && response.messageObj?.statusMessage !== null) {
+            return response.messageObj?.statusMessage;
+        }
+        const errorDetail = response.data?.api_request?.error?.detail;
+        if (errorDetail) {
+            return JSON.stringify(errorDetail);
+        }
+        const errorMessage = response.data?.api_request?.error?.message;
+        if (errorMessage) {
+            return JSON.stringify(errorMessage);
+        }
+        return undefined;
+    }
+    /**
+     * 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.
+     */
+    async getQueuedDocument(queueId) {
+        const queueResponse = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentQueueReqGet).call(this, queueId);
+        const queueStatusCode = queueResponse.messageObj.statusCode;
+        if (!isValidAsyncResponse(queueResponse)) {
+            handleError(this.urlName, queueResponse, this.extractStatusMessage(queueResponse));
+        }
+        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 feedback
+     * @param {string} documentId
+     */
+    async getDocument(documentId) {
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, documentId);
+        if (!isValidAsyncResponse(response)) {
+            handleError("document", response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    /**
+     * Send a feedback
+     * @param {string} documentId - ID of the document to send feedback to.
+     * @param {StringDict} feedback - Feedback object to send.
+     */
+    async sendFeedback(documentId, feedback) {
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentFeedbackPutReq).call(this, documentId, feedback);
+        if (!isValidSyncResponse(response)) {
+            handleError("feedback", response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param predictUrl
+     * @param includeWords
+     * @param fullText
+     * @param cropper
+     * @param rag
+     * @param workflowId
+     */
+    async sendFileForPrediction(input, predictUrl, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
+        const searchParams = new URLSearchParams();
+        if (cropper) {
+            searchParams.set("cropper", "true");
+        }
+        if (rag) {
+            searchParams.set("rag", "true");
+        }
+        if (fullText) {
+            searchParams.set("full_text_ocr", "true");
+        }
+        const form = new FormData();
+        if (input instanceof LocalInputSource && input.fileObject instanceof Buffer) {
+            form.set("document", new Blob([input.fileObject]), input.filename);
+        }
+        else {
+            form.set("document", input.fileObject);
+        }
+        if (includeWords) {
+            form.set("include_mvision", "true");
+        }
+        let path;
+        if (workflowId === undefined) {
+            path = `${this.urlRoot}/${predictUrl}`;
+        }
+        else {
+            path = `/v1/workflows/${workflowId}/predict_async`;
+        }
+        if (searchParams.toString().length > 0) {
+            path += `?${searchParams}`;
+        }
+        const options = {
+            method: "POST",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: path,
+            timeout: this.settings.timeout,
+            body: form,
+        };
+        return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+    }
+}
+_Endpoint_instances = new WeakSet(), _Endpoint_predictReqPost = function _Endpoint_predictReqPost(input, includeWords = false, fullText = false, cropper = false) {
+    return this.sendFileForPrediction(input, "predict", includeWords, fullText, cropper);
+}, _Endpoint_predictAsyncReqPost = function _Endpoint_predictAsyncReqPost(
+/**
+ * Make a request to POST a document for async prediction.
+ * @param input
+ * @param includeWords
+ * @param fullText
+ * @param cropper
+ * @param rag
+ * @param workflowId
+ */
+input, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
+    return this.sendFileForPrediction(input, "predict_async", includeWords, fullText, cropper, rag, workflowId);
+}, _Endpoint_documentQueueReqGet = 
+/**
+ * Make a request to GET the status of a document in the queue.
+ * @param queueId
+ */
+async function _Endpoint_documentQueueReqGet(queueId) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `${this.urlRoot}/documents/queue/${queueId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _Endpoint_documentGetReq = 
+/**
+ * Make a request to GET a document.
+ * @param documentId
+ */
+async function _Endpoint_documentGetReq(documentId) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `${this.urlRoot}/documents/${documentId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _Endpoint_documentFeedbackPutReq = 
+/**
+ * Make a request to PUT a document feedback.
+ * @param documentId
+ * @param feedback
+ */
+async function _Endpoint_documentFeedbackPutReq(documentId, feedback) {
+    const options = {
+        method: "PUT",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `/v1/documents/${documentId}/feedback`,
+        body: JSON.stringify(feedback),
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+};