mindee 4.28.0 → 4.29.0-rc2

package/src/clientV2.js

@@ -0,0 +1,216 @@
+"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 _ClientV2_instances, _ClientV2_setAsyncParams;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientV2 = void 0;
+const input_1 = require("./input");
+const handler_1 = require("./errors/handler");
+const logger_1 = require("./logger");
+const promises_1 = require("node:timers/promises");
+const mindeeApiV2_1 = require("./http/mindeeApiV2");
+const mindeeError_1 = require("./errors/mindeeError");
+/**
+ * Mindee Client V2 class that centralizes most basic operations.
+ *
+ * @category ClientV2
+ */
+class ClientV2 {
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, throwOnError, debug } = {
+        apiKey: "",
+        throwOnError: true,
+        debug: false,
+    }) {
+        _ClientV2_instances.add(this);
+        this.mindeeApi = new mindeeApiV2_1.MindeeApiV2(apiKey);
+        handler_1.errorHandler.throwOnError = throwOnError ?? true;
+        logger_1.logger.level =
+            debug ?? process.env.MINDEE_DEBUG
+                ? logger_1.LOG_LEVELS["debug"]
+                : logger_1.LOG_LEVELS["warn"];
+        logger_1.logger.debug("ClientV2 initialized");
+    }
+    /**
+     * Send the document to an asynchronous endpoint and return its ID in the queue.
+     * @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 enqueueInference(inputSource, params) {
+        if (inputSource === undefined) {
+            throw new Error("The 'enqueue' function requires an input document.");
+        }
+        return await this.mindeeApi.reqPostInferenceEnqueue(inputSource, params);
+    }
+    /**
+     * Retrieves an inference.
+     *
+     * @param inferenceId id of the queue to poll.
+     * @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 getInference(inferenceId) {
+        return await this.mindeeApi.reqGetInference(inferenceId);
+    }
+    /**
+     * Get the status of an inference that was previously enqueued.
+     * Can be used for polling.
+     *
+     * @param jobId id of the queue to poll.
+     * @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 getJob(jobId) {
+        return await this.mindeeApi.reqGetJob(jobId);
+    }
+    /**
+     * Send a document to an endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param inputDoc document 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 enqueueAndGetInference(inputDoc, params) {
+        const validatedAsyncParams = __classPrivateFieldGet(this, _ClientV2_instances, "m", _ClientV2_setAsyncParams).call(this, params.pollingOptions);
+        const enqueueResponse = await this.enqueueInference(inputDoc, params);
+        if (enqueueResponse.job.id === undefined || enqueueResponse.job.id.length === 0) {
+            logger_1.logger.error(`Failed enqueueing:\n${enqueueResponse.getRawHttp()}`);
+            throw Error("Enqueueing of the document failed.");
+        }
+        const queueId = enqueueResponse.job.id;
+        logger_1.logger.debug(`Successfully enqueued document with job id: ${queueId}.`);
+        await (0, promises_1.setTimeout)(validatedAsyncParams.initialDelaySec * 1000, undefined, validatedAsyncParams.initialTimerOptions);
+        let retryCounter = 1;
+        let pollResults = await this.getJob(queueId);
+        while (retryCounter < validatedAsyncParams.maxRetries) {
+            if (pollResults.job.status === "Failed") {
+                break;
+            }
+            if (pollResults.job.status === "Processed") {
+                return this.getInference(pollResults.job.id);
+            }
+            logger_1.logger.debug(`Polling server for parsing result with queueId: ${queueId}.
+Attempt n°${retryCounter}/${validatedAsyncParams.maxRetries}.
+Job status: ${pollResults.job.status}.`);
+            await (0, promises_1.setTimeout)(validatedAsyncParams.delaySec * 1000, undefined, validatedAsyncParams.recurringTimerOptions);
+            pollResults = await this.getJob(queueId);
+            retryCounter++;
+        }
+        const error = pollResults.job.error;
+        if (error) {
+            throw new mindeeError_1.MindeeHttpErrorV2(error.status, error.detail);
+        }
+        throw Error("Asynchronous parsing request timed out after " +
+            validatedAsyncParams.delaySec * retryCounter +
+            " seconds");
+    }
+    /**
+     * Load an input source from a local path.
+     * @param inputPath
+     */
+    sourceFromPath(inputPath) {
+        return new input_1.PathInput({
+            inputPath: inputPath,
+        });
+    }
+    /**
+     * Load an input source from a base64 encoded string.
+     * @param inputString input content, as a string.
+     * @param filename file name.
+     */
+    sourceFromBase64(inputString, filename) {
+        return new input_1.Base64Input({
+            inputString: inputString,
+            filename: filename,
+        });
+    }
+    /**
+     * Load an input source from a `stream.Readable` object.
+     * @param inputStream input content, as a readable stream.
+     * @param filename file name.
+     */
+    sourceFromStream(inputStream, filename) {
+        return new input_1.StreamInput({
+            inputStream: inputStream,
+            filename: filename,
+        });
+    }
+    /**
+     * Load an input source from bytes.
+     * @param inputBytes input content, as a Uint8Array or Buffer.
+     * @param filename file name.
+     */
+    sourceFromBytes(inputBytes, filename) {
+        return new input_1.BytesInput({
+            inputBytes: inputBytes,
+            filename: filename,
+        });
+    }
+    /**
+     * Load an input source from a Buffer.
+     * @param buffer input content, as a buffer.
+     * @param filename file name.
+     */
+    sourceFromBuffer(buffer, filename) {
+        return new input_1.BufferInput({
+            buffer: buffer,
+            filename: filename,
+        });
+    }
+    /**
+     * Load an input source from a URL.
+     * @param url input url. Must be HTTPS.
+     */
+    sourceFromUrl(url) {
+        return new input_1.UrlInput({
+            url: url,
+        });
+    }
+}
+exports.ClientV2 = ClientV2;
+_ClientV2_instances = new WeakSet(), _ClientV2_setAsyncParams = function _ClientV2_setAsyncParams(asyncParams = undefined) {
+    const minDelaySec = 1;
+    const minInitialDelay = 1;
+    const minRetries = 2;
+    let newAsyncParams;
+    if (asyncParams === undefined) {
+        newAsyncParams = {
+            delaySec: 1.5,
+            initialDelaySec: 2,
+            maxRetries: 80
+        };
+    }
+    else {
+        newAsyncParams = { ...asyncParams };
+        if (!newAsyncParams.delaySec ||
+            !newAsyncParams.initialDelaySec ||
+            !newAsyncParams.maxRetries) {
+            throw Error("Invalid polling options.");
+        }
+        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;
+};

package/src/errors/mindeeError.d.ts

@@ -16,3 +16,11 @@ export declare class MindeeImageError extends MindeeError {
 export declare class MindeePdfError extends MindeeError {
     constructor(message: string);
 }
+export declare class MindeeApiV2Error extends MindeeError {
+    constructor(message: string);
+}
+export declare class MindeeHttpErrorV2 extends MindeeError {
+    status: number;
+    detail: string;
+    constructor(status: number, detail: string);
+}

package/src/errors/mindeeError.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MindeePdfError = exports.MindeeImageError = exports.MindeeMimeTypeError = exports.MindeeError = void 0;
+exports.MindeeHttpErrorV2 = exports.MindeeApiV2Error = exports.MindeePdfError = exports.MindeeImageError = exports.MindeeMimeTypeError = exports.MindeeError = void 0;
 /**
  * Main Mindee Error custom class.
  */
@@ -35,3 +35,19 @@ class MindeePdfError extends MindeeError {
     }
 }
 exports.MindeePdfError = MindeePdfError;
+class MindeeApiV2Error extends MindeeError {
+    constructor(message) {
+        super(message);
+        this.name = "MindeeApiV2Error";
+    }
+}
+exports.MindeeApiV2Error = MindeeApiV2Error;
+class MindeeHttpErrorV2 extends MindeeError {
+    constructor(status, detail) {
+        super(`HTTP ${status} - ${detail}`);
+        this.status = status;
+        this.detail = detail;
+        this.name = "MindeeHttpErrorV2";
+    }
+}
+exports.MindeeHttpErrorV2 = MindeeHttpErrorV2;

package/src/http/apiSettings.d.ts

@@ -1,18 +1,12 @@
+import { BaseSettings, MindeeApiConstructorProps } from "./baseSettings";
 export declare const API_KEY_ENVVAR_NAME: string;
 export declare const API_HOST_ENVVAR_NAME: string;
 export declare const STANDARD_API_OWNER: string;
 export declare const TIMEOUT_DEFAULT: number;
-interface MindeeApiConstructorProps {
-    apiKey: string;
-}
-export declare class ApiSettings {
+export declare class ApiSettings extends BaseSettings {
     apiKey: string;
     baseHeaders: Record<string, string>;
-    hostname: string;
-    timeout: number;
     constructor({ apiKey, }: MindeeApiConstructorProps);
-    protected getUserAgent(): string;
     protected apiKeyFromEnv(): string;
     protected hostnameFromEnv(): string;
 }
-export {};

package/src/http/apiSettings.js

@@ -1,40 +1,17 @@
 "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.ApiSettings = exports.TIMEOUT_DEFAULT = exports.STANDARD_API_OWNER = exports.API_HOST_ENVVAR_NAME = exports.API_KEY_ENVVAR_NAME = void 0;
 /* eslint-disable @typescript-eslint/naming-convention */
 const logger_1 = require("../logger");
-const package_json_1 = require("../../package.json");
-const os = __importStar(require("os"));
+const baseSettings_1 = require("./baseSettings");
 exports.API_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
 exports.API_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
 exports.STANDARD_API_OWNER = "mindee";
 exports.TIMEOUT_DEFAULT = 120;
 const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
-class ApiSettings {
+class ApiSettings extends baseSettings_1.BaseSettings {
     constructor({ apiKey = "", }) {
+        super();
         if (!apiKey || apiKey.length === 0) {
             this.apiKey = this.apiKeyFromEnv();
         }
@@ -49,21 +26,6 @@ class ApiSettings {
             "User-Agent": this.getUserAgent(),
             Authorization: `Token ${this.apiKey}`,
         };
-        this.hostname = this.hostnameFromEnv();
-        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : exports.TIMEOUT_DEFAULT;
-    }
-    getUserAgent() {
-        let platform = os.type().toLowerCase();
-        if (platform.includes("darwin")) {
-            platform = "macos";
-        }
-        else if (platform.includes("window")) {
-            platform = "windows";
-        }
-        else if (platform.includes("bsd")) {
-            platform = "bsd";
-        }
-        return `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${platform}`;
     }
     apiKeyFromEnv() {
         const envVarValue = process.env[exports.API_KEY_ENVVAR_NAME];

package/src/http/apiSettingsV2.d.ts

@@ -0,0 +1,10 @@
+import { BaseSettings, MindeeApiConstructorProps } from "./baseSettings";
+export declare const API_V2_KEY_ENVVAR_NAME: string;
+export declare const API_V2_HOST_ENVVAR_NAME: string;
+export declare class ApiSettingsV2 extends BaseSettings {
+    apiKey: string;
+    baseHeaders: Record<string, string>;
+    constructor({ apiKey, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}

package/src/http/apiSettingsV2.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSettingsV2 = exports.API_V2_HOST_ENVVAR_NAME = exports.API_V2_KEY_ENVVAR_NAME = void 0;
+/* eslint-disable @typescript-eslint/naming-convention */
+const logger_1 = require("../logger");
+const baseSettings_1 = require("./baseSettings");
+const mindeeError_1 = require("../errors/mindeeError");
+exports.API_V2_KEY_ENVVAR_NAME = "MINDEE_V2_API_KEY";
+exports.API_V2_HOST_ENVVAR_NAME = "MINDEE_V2_API_HOST";
+const DEFAULT_MINDEE_API_HOST = "api-v2.mindee.net";
+class ApiSettingsV2 extends baseSettings_1.BaseSettings {
+    constructor({ apiKey = "", }) {
+        super();
+        if (!apiKey || apiKey.length === 0) {
+            this.apiKey = this.apiKeyFromEnv();
+        }
+        else {
+            this.apiKey = apiKey;
+        }
+        if (!this.apiKey || this.apiKey.length === 0) {
+            throw new mindeeError_1.MindeeApiV2Error("Your API V2 key could not be set, check your Client Configuration\n."
+                + `You can set this using the ${exports.API_V2_KEY_ENVVAR_NAME} environment variable.`);
+        }
+        this.baseHeaders = {
+            "User-Agent": this.getUserAgent(),
+            Authorization: `${apiKey}`,
+        };
+    }
+    apiKeyFromEnv() {
+        const envVarValue = process.env[exports.API_V2_KEY_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set API key from environment: ${exports.API_V2_KEY_ENVVAR_NAME}`);
+            return envVarValue;
+        }
+        return "";
+    }
+    hostnameFromEnv() {
+        const envVarValue = process.env[exports.API_V2_HOST_ENVVAR_NAME];
+        if (envVarValue) {
+            logger_1.logger.debug(`Set the API hostname to ${envVarValue}`);
+            return envVarValue;
+        }
+        return DEFAULT_MINDEE_API_HOST;
+    }
+}
+exports.ApiSettingsV2 = ApiSettingsV2;

package/src/http/baseEndpoint.d.ts

@@ -22,7 +22,7 @@ export declare abstract class BaseEndpoint {
      * @param inputDoc input document.
      * @param pageOptions page cutting options.
      */
-    protected cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
+    static cutDocPages(inputDoc: InputSource, pageOptions: PageOptions): Promise<void>;
     /**
      * Reads a response from the API and processes it.
      * @param options options related to the request itself.
@@ -30,5 +30,5 @@ export declare abstract class BaseEndpoint {
      * @param reject promise rejection reason.
      * @returns the processed request.
      */
-    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
+    static readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
 }

package/src/http/baseEndpoint.js

@@ -17,9 +17,9 @@ class BaseEndpoint {
      * @param inputDoc input document.
      * @param pageOptions page cutting options.
      */
-    async cutDocPages(inputDoc, pageOptions) {
+    static async cutDocPages(inputDoc, pageOptions) {
         if (inputDoc instanceof input_1.LocalInputSource && inputDoc.isPdf()) {
-            await inputDoc.cutPdf(pageOptions);
+            await inputDoc.applyPageOptions(pageOptions);
         }
     }
     /**
@@ -29,7 +29,7 @@ class BaseEndpoint {
      * @param reject promise rejection reason.
      * @returns the processed request.
      */
-    readResponse(options, resolve, reject) {
+    static 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

package/src/http/baseSettings.d.ts

@@ -0,0 +1,11 @@
+export interface MindeeApiConstructorProps {
+    apiKey?: string;
+}
+export declare abstract class BaseSettings {
+    hostname: string;
+    timeout: number;
+    protected constructor();
+    protected getUserAgent(): string;
+    protected abstract apiKeyFromEnv(): string;
+    protected abstract hostnameFromEnv(): string;
+}

package/src/http/baseSettings.js

@@ -0,0 +1,59 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSettings = void 0;
+const package_json_1 = require("../../package.json");
+const os = __importStar(require("os"));
+const apiSettings_1 = require("./apiSettings");
+class BaseSettings {
+    constructor() {
+        this.hostname = this.hostnameFromEnv();
+        this.timeout = process.env.MINDEE_REQUEST_TIMEOUT ? parseInt(process.env.MINDEE_REQUEST_TIMEOUT) : apiSettings_1.TIMEOUT_DEFAULT;
+    }
+    getUserAgent() {
+        let platform = os.type().toLowerCase();
+        if (platform.includes("darwin")) {
+            platform = "macos";
+        }
+        else if (platform.includes("window")) {
+            platform = "windows";
+        }
+        else if (platform.includes("bsd")) {
+            platform = "bsd";
+        }
+        return `mindee-api-nodejs@v${package_json_1.version} nodejs-${process.version} ${platform}`;
+    }
+}
+exports.BaseSettings = BaseSettings;

package/src/http/endpoint.js

@@ -44,7 +44,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
     async predict(params) {
         await params.inputDoc.init();
         if (params.pageOptions !== undefined) {
-            await super.cutDocPages(params.inputDoc, params.pageOptions);
+            await baseEndpoint_1.BaseEndpoint.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 (!(0, responseValidation_1.isValidSyncResponse)(response)) {
@@ -62,7 +62,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
     async predictAsync(params) {
         await params.inputDoc.init();
         if (params.pageOptions !== undefined) {
-            await super.cutDocPages(params.inputDoc, params.pageOptions);
+            await baseEndpoint_1.BaseEndpoint.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 (!(0, responseValidation_1.isValidAsyncResponse)(response)) {
@@ -181,7 +181,7 @@ class Endpoint extends baseEndpoint_1.BaseEndpoint {
                 path: path,
                 timeout: this.settings.timeout,
             };
-            const req = this.readResponse(options, resolve, reject);
+            const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
             form.pipe(req);
             // potential ECONNRESET if we don't end the request.
             req.end();
@@ -211,7 +211,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `${this.urlRoot}/documents/queue/${queueId}`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         // potential ECONNRESET if we don't end the request.
         req.end();
     });
@@ -223,7 +223,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `${this.urlRoot}/documents/${documentId}`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         // potential ECONNRESET if we don't end the request.
         req.end();
     });
@@ -235,7 +235,7 @@ input, includeWords = false, fullText = false, cropper = false, rag = false, wor
             hostname: this.settings.hostname,
             path: `/v1/documents/${documentId}/feedback`,
         };
-        const req = this.readResponse(options, resolve, reject);
+        const req = baseEndpoint_1.BaseEndpoint.readResponse(options, resolve, reject);
         req.write(JSON.stringify(feedback));
         // potential ECONNRESET if we don't end the request.
         req.end();

package/src/http/mindeeApiV2.d.ts

@@ -0,0 +1,34 @@
+import { ApiSettingsV2 } from "./apiSettingsV2";
+import { InferenceParameters } from "../clientV2";
+import { InferenceResponse, JobResponse } from "../parsing/v2";
+import { LocalInputSource } from "../input";
+export declare class MindeeApiV2 {
+    #private;
+    settings: ApiSettingsV2;
+    constructor(apiKey?: string);
+    /**
+     * Sends a file to the inference queue.
+     * @param inputDoc Local file loaded as an input.
+     * @param params {InferenceParameters} parameters relating to the enqueueing options.
+     * @category V2
+     * @throws Error if the server's response contains one.
+     * @returns a `Promise` containing a job response.
+     */
+    reqPostInferenceEnqueue(inputDoc: LocalInputSource, params: InferenceParameters): Promise<JobResponse>;
+    /**
+     * Requests the job of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param inferenceId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    reqGetInference(inferenceId: string): Promise<InferenceResponse>;
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param jobId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    reqGetJob(jobId: string): Promise<JobResponse>;
+}