mindee 4.3.1 → 4.3.3

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # CHANGELOG
 
+## v4.3.2 - 2023-11-07
+### Changes
+* :recycle: update invoice splitter
+
+### Fixes
+* :bug: fix display issues when products didn't have pages
+* :memo: fix doc typos
+
+
+## v4.3.2 - 2023-10-04
+### Changes
+* :arrow_up: dependency upgrade
+* :recycle: minor refactoring
+
+
 ## v4.3.1 - 2023-09-20
 ### Fixes
 * :bug: take line height tolerance into account when evaluating fields

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mindee",
-    "version": "4.3.1",
+    "version": "4.3.3",
     "description": "Mindee Client Library for Node.js",
     "main": "src/index.js",
     "bin": "bin/mindee.js",
@@ -45,9 +45,10 @@
         "@types/node": "^18.15.11",
         "@typescript-eslint/eslint-plugin": "^5.57.1",
         "@typescript-eslint/parser": "^5.57.1",
-        "chai": "^4.3.7",
-        "eslint": "^8.47.0",
-        "lint-staged": "^13.2.3",
+        "chai": "^4.3.10",
+        "eslint": "^8.49.0",
+        "eslint-plugin-jsdoc": "^46.8.2",
+        "lint-staged": "^13.3.0",
         "mocha": "^10.1.0",
         "nock": "^13.3.3",
         "ts-node": "^10.9.1",

package/src/cli.js

@@ -162,11 +162,10 @@ const CLI_COMMAND_CONFIG = new Map([
 // EXECUTE THE COMMANDS
 //
 function initClient(options) {
-    const mindeeClient = new client_1.Client({
+    return new client_1.Client({
         apiKey: options.apiKey,
         debug: options.debug,
     });
-    return mindeeClient;
 }
 function getConfig(command) {
     const conf = CLI_COMMAND_CONFIG.get(command);
@@ -187,11 +186,10 @@ function getPageOptions(options) {
     return pageOptions;
 }
 function getPredictParams(options) {
-    const predictParams = {
+    return {
         allWords: options.allWords,
         cropper: options.cropper,
     };
-    return predictParams;
 }
 async function callParse(productClass, command, inputPath, options) {
     const mindeeClient = initClient(options);
@@ -250,6 +248,19 @@ async function callEnqueueAndParse(productClass, command, inputPath, options) {
         printResponse(response.document, options);
     }
 }
+async function callGetDocument(productClass, documentId, options) {
+    const mindeeClient = initClient(options);
+    const response = await mindeeClient.getDocument(productClass, documentId);
+    printResponse(response.document, options);
+}
+async function callSendFeedback(productClass, documentId, feedbackStr, options) {
+    const mindeeClient = initClient(options);
+    const feedback = {
+        feedback: JSON.parse(feedbackStr),
+    };
+    const response = await mindeeClient.sendFeedback(productClass, documentId, feedback);
+    console.log(response.feedback);
+}
 function printResponse(document, options) {
     if (options.allWords) {
         document.ocr?.mVisionV1.pages.forEach((page) => {
@@ -287,13 +298,16 @@ function addDisplayOptions(prog) {
     prog.option("-p, --pages", "show content of individual pages");
 }
 function routeSwitchboard(command, inputPath, allOptions) {
-    const docClass = getConfig(command.name()).docClass;
+    if (command.parent === null || command.parent === undefined) {
+        throw new Error(`Improperly configured command: ${command.name()}`);
+    }
+    const docClass = getConfig(command.parent.name()).docClass;
     if ("async" in command.opts() && command.opts()["async"]) {
         return callEnqueueAndParse(docClass, command.name(), inputPath, allOptions);
     }
     return callParse(docClass, command.name(), inputPath, allOptions);
 }
-function addAction(prog) {
+function addPredictAction(prog) {
     if (prog.name() === COMMAND_CUSTOM) {
         prog.action(function (inputPath, options, command) {
             const allOptions = {
@@ -318,11 +332,33 @@ function addAction(prog) {
     }
 }
 function cli() {
-    program.name("mindee");
-    program.option("-d, --debug", "high verbosity mode");
+    program.name("mindee")
+        .description("Command line interface for Mindee products.")
+        .option("-d, --debug", "high verbosity mode");
     CLI_COMMAND_CONFIG.forEach((info, name) => {
-        const prog = program.command(name);
-        prog.description(`${info.displayName} document`);
+        const productCmd = program.command(name)
+            .description(info.displayName);
+        if (info.async) {
+            const getDocProductCmd = productCmd.command("fetch")
+                .description("Fetch previously parsed results.")
+                .argument("<documentId>", "Unique ID of the document.")
+                .action(async (documentId, options) => {
+                const docClass = getConfig(name).docClass;
+                await callGetDocument(docClass, documentId, { ...options, ...productCmd.opts(), ...program.opts() });
+            });
+            addMainOptions(getDocProductCmd);
+        }
+        const feedbackProductCmd = productCmd.command("feedback")
+            .description("Send feedback for a document.")
+            .argument("<documentId>", "Unique ID of the document.")
+            .argument("<feedback>", "Feedback to send, ex '{\"key\": \"value\"}'.")
+            .action(async (documentId, feedback, options) => {
+            const docClass = getConfig(name).docClass;
+            await callSendFeedback(docClass, documentId, feedback, { ...options, ...productCmd.opts(), ...program.opts() });
+        });
+        addMainOptions(feedbackProductCmd);
+        const predictProductCmd = productCmd.command("parse")
+            .description("Send a file for parsing.");
         if (info.async) {
             const asyncOpt = new commander_1.Option("-A, --async", "Call asynchronously");
             if (info.sync) {
@@ -332,15 +368,15 @@ function cli() {
                 asyncOpt.default(true);
                 asyncOpt.hideHelp();
             }
-            prog.addOption(asyncOpt);
+            predictProductCmd.addOption(asyncOpt);
         }
         if (name === COMMAND_CUSTOM) {
-            addCustomPostOptions(prog);
+            addCustomPostOptions(predictProductCmd);
         }
-        addMainOptions(prog);
-        addDisplayOptions(prog);
-        addPostOptions(prog, info);
-        addAction(prog);
+        addMainOptions(predictProductCmd);
+        addDisplayOptions(predictProductCmd);
+        addPostOptions(predictProductCmd, info);
+        addPredictAction(predictProductCmd);
     });
     program.parse(process.argv);
 }

package/src/client.d.ts

@@ -4,7 +4,7 @@
 import { Readable } from "stream";
 import { InputSource, PageOptions } from "./input";
 import { Endpoint } from "./http";
-import { Inference, AsyncPredictResponse, StringDict, PredictResponse } from "./parsing/common";
+import { AsyncPredictResponse, FeedbackResponse, Inference, PredictResponse, StringDict } from "./parsing/common";
 /**
  * Options relating to predictions.
  */
@@ -63,14 +63,14 @@ export declare class Client {
     /** Key of the API. */
     protected apiKey: string;
     /**
-     * @param options options for the initialization of a client.
+     * @param {ClientOptions} options options for the initialization of a client.
      */
     constructor({ apiKey, throwOnError, debug }?: ClientOptions);
     /**
      * 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 document to parse.
+     * @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
@@ -80,6 +80,7 @@ export declare class Client {
     /**
      * 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.
@@ -97,6 +98,35 @@ export declare class Client {
      * parsing is complete.
      */
     parseQueued<T extends Inference>(productClass: new (httpResponse: StringDict) => T, queueId: string, params?: PredictOptions): Promise<AsyncPredictResponse<T>>;
+    /**
+     * 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.
+     */
+    getDocument<T extends Inference>(productClass: new (httpResponse: StringDict) => T, documentId: string, params?: {
+        endpoint?: Endpoint;
+    }): Promise<PredictResponse<T>>;
+    /**
+     * Send a 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.
+     */
+    sendFeedback<T extends Inference>(productClass: new (httpResponse: StringDict) => T, documentId: string, feedback: StringDict, params?: {
+        endpoint?: Endpoint;
+    }): Promise<FeedbackResponse>;
     /**
      * Send a document to an asynchronous endpoint and poll the server until the result is sent or
      * until the maximum amount of tries is reached.
@@ -118,13 +148,12 @@ export declare class Client {
     protected getBooleanParam(param?: boolean): boolean;
     /**
      * Creates a custom endpoint with the given values. Raises an error if the endpoint is invalid.
-     * @param productClass product class to use for calling the API and parsing the response.
      * @param endpointName Name of the custom Endpoint.
      * @param accountName Name of the account tied to the Endpoint.
-     * @param version Version of the custom 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 a new endpoint
+     * @returns Endpoint a new product endpoint
      */
     createEndpoint(endpointName: string, accountName: string, endpointVersion?: string): Endpoint;
     /**

package/src/client.js

@@ -4,7 +4,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     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_validateAsyncParams, _Client_buildEndpoint, _Client_initializeOTSEndpoint, _Client_cleanAccountName, _Client_getEndpoint;
+var _Client_instances, _Client_validateAsyncParams, _Client_buildProductEndpoint, _Client_buildApiSettings, _Client_initializeOTSEndpoint, _Client_cleanAccountName, _Client_getOtsEndpoint;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const input_1 = require("./input");
@@ -22,7 +22,7 @@ const promises_1 = require("node:timers/promises");
  */
 class Client {
     /**
-     * @param options options for the initialization of a client.
+     * @param {ClientOptions} options options for the initialization of a client.
      */
     constructor({ apiKey, throwOnError, debug } = {
         apiKey: "",
@@ -42,7 +42,7 @@ class Client {
      * 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 document to parse.
+     * @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
@@ -69,6 +69,7 @@ class Client {
     /**
      * 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.
@@ -102,6 +103,39 @@ class Client {
         const docResponse = await endpoint.getQueuedDocument(queueId);
         return new common_1.AsyncPredictResponse(productClass, docResponse.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 common_1.PredictResponse(productClass, response.data);
+    }
+    /**
+     * Send a 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 common_1.FeedbackResponse(response.data);
+    }
     /**
      * Send a document to an asynchronous endpoint and poll the server until the result is sent or
      * until the maximum amount of tries is reached.
@@ -162,13 +196,12 @@ Job status: ${pollResults.job.status}.`);
     }
     /**
      * Creates a custom endpoint with the given values. Raises an error if the endpoint is invalid.
-     * @param productClass product class to use for calling the API and parsing the response.
      * @param endpointName Name of the custom Endpoint.
      * @param accountName Name of the account tied to the Endpoint.
-     * @param version Version of the custom 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 a new endpoint
+     * @returns Endpoint a new product endpoint
      */
     createEndpoint(endpointName, accountName, endpointVersion) {
         const cleanAccountName = __classPrivateFieldGet(this, _Client_instances, "m", _Client_cleanAccountName).call(this, product_1.CustomV1, accountName);
@@ -183,7 +216,7 @@ Job status: ${pollResults.job.status}.`);
         else {
             cleanEndpointVersion = endpointVersion;
         }
-        return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildEndpoint).call(this, endpointName, cleanAccountName, cleanEndpointVersion);
+        return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildProductEndpoint).call(this, endpointName, cleanAccountName, cleanEndpointVersion);
     }
     /**
      * Load an input document from a local path.
@@ -262,20 +295,18 @@ _Client_instances = new WeakSet(), _Client_validateAsyncParams = function _Clien
     if (!Number.isInteger(asyncParams.maxRetries)) {
         throw Error("Retry amount must be an integer.");
     }
-}, _Client_buildEndpoint = function _Client_buildEndpoint(endpointName, accountName, endpointVersion) {
-    const apiSettings = new http_1.MindeeApi({
+}, _Client_buildProductEndpoint = function _Client_buildProductEndpoint(endpointName, accountName, endpointVersion) {
+    return new http_1.Endpoint(endpointName, accountName, endpointVersion, __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildApiSettings).call(this));
+}, _Client_buildApiSettings = function _Client_buildApiSettings() {
+    return new http_1.ApiSettings({
         apiKey: this.apiKey,
-        urlName: endpointName,
-        version: endpointVersion,
-        owner: accountName,
     });
-    return new http_1.Endpoint(endpointName, accountName, endpointVersion, apiSettings);
 }, _Client_initializeOTSEndpoint = function _Client_initializeOTSEndpoint(productClass) {
     if (productClass.name === "CustomV1") {
         throw new Error("Incorrect parameters for Custom build.");
     }
-    const [endpointName, endpointVersion] = __classPrivateFieldGet(this, _Client_instances, "m", _Client_getEndpoint).call(this, productClass);
-    return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildEndpoint).call(this, endpointName, http_1.STANDARD_API_OWNER, endpointVersion);
+    const [endpointName, endpointVersion] = __classPrivateFieldGet(this, _Client_instances, "m", _Client_getOtsEndpoint).call(this, productClass);
+    return __classPrivateFieldGet(this, _Client_instances, "m", _Client_buildProductEndpoint).call(this, endpointName, http_1.STANDARD_API_OWNER, endpointVersion);
 }, _Client_cleanAccountName = function _Client_cleanAccountName(productClass, accountName) {
     if (productClass.name === "CustomV1") {
         if (!accountName || accountName.length === 0) {
@@ -285,7 +316,7 @@ _Client_instances = new WeakSet(), _Client_validateAsyncParams = function _Clien
         return accountName;
     }
     return http_1.STANDARD_API_OWNER;
-}, _Client_getEndpoint = function _Client_getEndpoint(productClass) {
+}, _Client_getOtsEndpoint = function _Client_getOtsEndpoint(productClass) {
     const [endpointName, endpointVersion] = inference_1.InferenceFactory.getEndpoint(productClass);
     return [endpointName, endpointVersion];
 };

package/src/http/apiSettings.d.ts

@@ -0,0 +1,15 @@
+export declare const API_KEY_ENVVAR_NAME: string;
+export declare const API_HOST_ENVVAR_NAME: string;
+export declare const STANDARD_API_OWNER: string;
+interface MindeeApiConstructorProps {
+    apiKey: string;
+}
+export declare class ApiSettings {
+    apiKey: string;
+    baseHeaders: Record<string, string>;
+    hostname: string;
+    constructor({ apiKey, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}
+export {};

package/src/http/{mindeeApi.js → apiSettings.js}

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (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;
+exports.ApiSettings = 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"));
@@ -32,31 +32,28 @@ 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, }) {
+class ApiSettings {
+    constructor({ apiKey = "", }) {
         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];
+            this.apiKey = this.apiKeyFromEnv();
         }
         else {
             this.apiKey = apiKey;
         }
+        if (!this.apiKey || this.apiKey.length === 0) {
+            throw new Error("Your API key could not be set, check your Client Configuration\n."
+                + `You can set this using the ${exports.API_KEY_ENVVAR_NAME} environment variable.`);
+        }
         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}`);
+            logger_1.logger.debug(`Set API key from environment: ${exports.API_KEY_ENVVAR_NAME}`);
             return envVarValue;
         }
         return "";
@@ -70,4 +67,4 @@ You can set this using the ${exports.API_KEY_ENVVAR_NAME} environment variable.`
         return DEFAULT_MINDEE_API_HOST;
     }
 }
-exports.MindeeApi = MindeeApi;
+exports.ApiSettings = ApiSettings;

package/src/http/baseEndpoint.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ApiSettings } from "./apiSettings";
+import { IncomingMessage, ClientRequest } from "http";
+import { RequestOptions } from "https";
+export interface EndpointResponse {
+    messageObj: IncomingMessage;
+    data: {
+        [key: string]: any;
+    };
+}
+/**
+ * Base endpoint for the Mindee API.
+ */
+export declare abstract class BaseEndpoint {
+    /** Settings relating to the API. */
+    settings: ApiSettings;
+    protected constructor(settings: ApiSettings);
+    /**
+     * Reads a response from the API and processes it.
+     * @param options options related to the request itself.
+     * @param resolve the resolved response
+     * @param reject promise rejection reason.
+     * @returns the processed request.
+     */
+    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
+}

package/src/http/baseEndpoint.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEndpoint = void 0;
+const logger_1 = require("../logger");
+const https_1 = require("https");
+/**
+ * Base endpoint for the Mindee API.
+ */
+class BaseEndpoint {
+    constructor(settings) {
+        this.settings = settings;
+    }
+    /**
+     * Reads a response from the API and processes it.
+     * @param options options related to the request itself.
+     * @param resolve the resolved response
+     * @param reject promise rejection reason.
+     * @returns the processed request.
+     */
+    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);
+                    resolve({
+                        messageObj: res,
+                        data: { reconstructedResponse: responseBody },
+                    });
+                }
+            });
+        });
+        req.on("error", (err) => {
+            reject(err);
+        });
+        return req;
+    }
+}
+exports.BaseEndpoint = BaseEndpoint;

package/src/http/endpoint.d.ts

@@ -1,20 +1,18 @@
-/// <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;
-    };
+import { ApiSettings } from "./apiSettings";
+import { BaseEndpoint, EndpointResponse } from "./baseEndpoint";
+import { StringDict } from "../parsing/common";
+export interface PredictParams {
+    inputDoc: InputSource;
+    includeWords: boolean;
+    pageOptions?: PageOptions;
+    cropper: boolean;
 }
 /**
- * Endpoint object class wrapper.
+ * Endpoint for a product (OTS or Custom).
  */
-export declare class Endpoint {
+export declare class Endpoint extends BaseEndpoint {
     #private;
     /** URL of a product. */
     urlName: string;
@@ -24,43 +22,42 @@ export declare class Endpoint {
     version: string;
     /** Entire root of the URL for API calls. */
     urlRoot: string;
-    /** Settings relating to the API. */
-    settings: MindeeApi;
-    constructor(urlName: string, owner: string, version: string, settings: MindeeApi);
+    constructor(urlName: string, owner: string, version: string, settings: ApiSettings);
     /**
      * Sends a prediction to the API and parses out the result.
      * Throws an error if the server's response contains one.
-     * @param params parameters relating to prediction options.
+     * @param {PredictParams} params parameters relating to prediction options.
      * @category Synchronous
      * @returns a `Promise` containing parsing results.
      */
-    predict(params: {
-        inputDoc: InputSource;
-        includeWords: boolean;
-        pageOptions?: PageOptions;
-        cropper: boolean;
-    }): Promise<EndpointResponse>;
+    predict(params: PredictParams): Promise<EndpointResponse>;
     /**
      * Enqueues a prediction to the API.
      * Throws an error if the server's response contains one.
-     * @param params parameters relating to prediction options.
+     * @param {PredictParams} params parameters relating to prediction options.
      * @category Asynchronous
      * @returns a `Promise` containing queue data.
      */
-    predictAsync(params: {
-        inputDoc: InputSource;
-        includeWords: boolean;
-        pageOptions?: PageOptions;
-        cropper: boolean;
-    }): Promise<EndpointResponse>;
+    predictAsync(params: PredictParams): Promise<EndpointResponse>;
     /**
      * Requests the results of a queued document from the API.
      * Throws an error if the server's response contains one.
-     * @param params parameters relating to prediction options.
+     * @param queueId The document's ID in the queue.
      * @category Asynchronous
      * @returns a `Promise` containing the parsed result.
      */
     getQueuedDocument(queueId: string): Promise<EndpointResponse>;
+    /**
+     * Send a feedback
+     * @param {string} documentId
+     */
+    getDocument(documentId: string): Promise<EndpointResponse>;
+    /**
+     * 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<EndpointResponse>;
     /**
      * Send a file to a prediction API.
      * @param input
@@ -69,12 +66,4 @@ export declare class Endpoint {
      * @param cropper
      */
     protected sendFileForPrediction(input: InputSource, predictUrl: string, includeWords?: boolean, cropper?: boolean): Promise<EndpointResponse>;
-    /**
-     * Reads a response from the API and processes it.
-     * @param options options related to the request itself.
-     * @param resolve the resolved response
-     * @param reject promise rejection reason.
-     * @returns the processed request.
-     */
-    protected readResponse(options: RequestOptions, resolve: (value: EndpointResponse | PromiseLike<EndpointResponse>) => void, reject: (reason?: any) => void): ClientRequest;
 }