mindee 4.3.2 → 4.4.0

package/src/http/endpoint.js

@@ -7,31 +7,30 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var _Endpoint_instances, _Endpoint_cutDocPages, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq;
+var _Endpoint_instances, _Endpoint_cutDocPages, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq, _Endpoint_documentFeedbackPutReq;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Endpoint = void 0;
-const https_1 = require("https");
 const url_1 = require("url");
 const form_data_1 = __importDefault(require("form-data"));
-const logger_1 = require("../logger");
 const base_1 = require("../input/base");
 const error_1 = require("./error");
+const baseEndpoint_1 = require("./baseEndpoint");
 /**
- * Endpoint object class wrapper.
+ * Endpoint for a product (OTS or Custom).
  */
-class Endpoint {
+class Endpoint extends baseEndpoint_1.BaseEndpoint {
     constructor(urlName, owner, version, settings) {
+        super(settings);
         _Endpoint_instances.add(this);
         this.owner = owner;
         this.urlName = urlName;
         this.version = version;
-        this.settings = settings;
         this.urlRoot = `/v1/products/${owner}/${urlName}/v${version}`;
     }
     /**
      * 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.
      */
@@ -50,7 +49,7 @@ class Endpoint {
     /**
      * 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.
      */
@@ -69,7 +68,7 @@ class Endpoint {
     /**
      * 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.
      */
@@ -90,6 +89,31 @@ class Endpoint {
         }
         return queueResponse;
     }
+    /**
+     * Send a feedback
+     * @param {string} documentId
+     */
+    async getDocument(documentId) {
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, documentId);
+        const statusCode = response.messageObj.statusCode;
+        if (statusCode === undefined || statusCode >= 400) {
+            (0, error_1.handleError)("document", response, statusCode, response.messageObj?.statusMessage);
+        }
+        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);
+        const statusCode = response.messageObj.statusCode;
+        if (statusCode === undefined || statusCode >= 400) {
+            (0, error_1.handleError)("feedback", response, statusCode, response.messageObj?.statusMessage);
+        }
+        return response;
+    }
     /**
      * Send a file to a prediction API.
      * @param input
@@ -132,57 +156,6 @@ class Endpoint {
             req.end();
         });
     }
-    /**
-     * 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.Endpoint = Endpoint;
 _Endpoint_instances = new WeakSet(), _Endpoint_cutDocPages = 
@@ -223,4 +196,17 @@ async function _Endpoint_cutDocPages(inputDoc, pageOptions) {
         // potential ECONNRESET if we don't end the request.
         req.end();
     });
+}, _Endpoint_documentFeedbackPutReq = function _Endpoint_documentFeedbackPutReq(documentId, feedback) {
+    return new Promise((resolve, reject) => {
+        const options = {
+            method: "PUT",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: `/v1/documents/${documentId}/feedback`,
+        };
+        const req = this.readResponse(options, resolve, reject);
+        req.write(JSON.stringify(feedback));
+        // potential ECONNRESET if we don't end the request.
+        req.end();
+    });
 };

package/src/http/error.d.ts

@@ -1,7 +1,7 @@
 import { MindeeError } from "../errors";
 import { StringDict } from "../parsing/common";
-import { EndpointResponse } from "./endpoint";
-export declare function handleError(url: string, response: EndpointResponse, code?: number, serverError?: string): void;
+import { EndpointResponse } from "./baseEndpoint";
+export declare function handleError(urlName: string, response: EndpointResponse, code?: number, serverError?: string): void;
 /**
  * `Error` wrapper for server (HTTP) errors.
  * Is used when an error is lacking a handled error code.
@@ -13,55 +13,55 @@ export declare class MindeeHttpError extends MindeeError {
     details: string | StringDict;
     /** Standard HTTP error code. */
     code?: number;
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Generic client errors.
  * Can include errors like InvalidQuery.
  */
 export declare class MindeeHttp400Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Can include errors like NoTokenSet or InvalidToken.
  */
 export declare class MindeeHttp401Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Regular AccessForbidden error.
  * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
  */
 export declare class MindeeHttp403Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 export declare class MindeeHttp404Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Rare error.
  * Can occasionally happen when unusually large documents are passed.
  */
 export declare class MindeeHttp413Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Usually corresponds to TooManyRequests errors.
  * Arises whenever too many calls to the API are made in quick succession.
  */
 export declare class MindeeHttp429Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Generic server errors.
  */
 export declare class MindeeHttp500Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }
 /**
  * Miscellaneous server errors.
  * Can include errors like RequestTimeout or GatewayTimeout.
  */
 export declare class MindeeHttp504Error extends MindeeHttpError {
-    constructor(httpError: StringDict, url: string, code?: number);
+    constructor(httpError: StringDict, urlName: string, code?: number);
 }

package/src/http/error.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MindeeHttp504Error = exports.MindeeHttp500Error = exports.MindeeHttp429Error = exports.MindeeHttp413Error = exports.MindeeHttp404Error = exports.MindeeHttp403Error = exports.MindeeHttp401Error = exports.MindeeHttp400Error = exports.MindeeHttpError = exports.handleError = void 0;
 const errors_1 = require("../errors");
 const handler_1 = require("../errors/handler");
-function handleError(url, response, code, serverError) {
+function handleError(urlName, response, code, serverError) {
     if (code === undefined) {
-        throw new MindeeHttpError({ message: "Missing HTTP Error code.", details: response.data, undefined }, url);
+        throw new MindeeHttpError({ message: "Missing HTTP Error code.", details: response.data, undefined }, urlName);
     }
     let errorObj;
     try {
@@ -69,31 +69,31 @@ function handleError(url, response, code, serverError) {
     let errorToThrow;
     switch (code) {
         case 400:
-            errorToThrow = new MindeeHttp400Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp400Error(errorObj, urlName, code);
             break;
         case 401:
-            errorToThrow = new MindeeHttp401Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp401Error(errorObj, urlName, code);
             break;
         case 403:
-            errorToThrow = new MindeeHttp403Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp403Error(errorObj, urlName, code);
             break;
         case 404:
-            errorToThrow = new MindeeHttp404Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp404Error(errorObj, urlName, code);
             break;
         case 413:
-            errorToThrow = new MindeeHttp413Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp413Error(errorObj, urlName, code);
             break;
         case 429:
-            errorToThrow = new MindeeHttp429Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp429Error(errorObj, urlName, code);
             break;
         case 500:
-            errorToThrow = new MindeeHttp500Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp500Error(errorObj, urlName, code);
             break;
         case 504:
-            errorToThrow = new MindeeHttp504Error(errorObj, url, code);
+            errorToThrow = new MindeeHttp504Error(errorObj, urlName, code);
             break;
         default:
-            errorToThrow = new MindeeHttpError(errorObj, url, code);
+            errorToThrow = new MindeeHttpError(errorObj, urlName, code);
             break;
     }
     handler_1.errorHandler.throw(errorToThrow);
@@ -104,8 +104,8 @@ exports.handleError = handleError;
  * Is used when an error is lacking a handled error code.
  */
 class MindeeHttpError extends errors_1.MindeeError {
-    constructor(httpError, url, code) {
-        super(`${url} API ${code} HTTP error: ${httpError.message}`);
+    constructor(httpError, urlName, code) {
+        super(`${urlName} API ${code} HTTP error: ${httpError.message}`);
         /** Description of the error. */
         this.message = "";
         /** Additional details on the error. */
@@ -122,8 +122,8 @@ exports.MindeeHttpError = MindeeHttpError;
  * Can include errors like InvalidQuery.
  */
 class MindeeHttp400Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp400Error";
     }
 }
@@ -132,8 +132,8 @@ exports.MindeeHttp400Error = MindeeHttp400Error;
  * Can include errors like NoTokenSet or InvalidToken.
  */
 class MindeeHttp401Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp401Error";
     }
 }
@@ -143,15 +143,15 @@ exports.MindeeHttp401Error = MindeeHttp401Error;
  * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
  */
 class MindeeHttp403Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp403Error";
     }
 }
 exports.MindeeHttp403Error = MindeeHttp403Error;
 class MindeeHttp404Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp404Error";
     }
 }
@@ -161,8 +161,8 @@ exports.MindeeHttp404Error = MindeeHttp404Error;
  * Can occasionally happen when unusually large documents are passed.
  */
 class MindeeHttp413Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp413Error";
     }
 }
@@ -172,8 +172,8 @@ exports.MindeeHttp413Error = MindeeHttp413Error;
  * Arises whenever too many calls to the API are made in quick succession.
  */
 class MindeeHttp429Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp429Error";
     }
 }
@@ -182,8 +182,8 @@ exports.MindeeHttp429Error = MindeeHttp429Error;
  * Generic server errors.
  */
 class MindeeHttp500Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp500Error";
     }
 }
@@ -193,8 +193,8 @@ exports.MindeeHttp500Error = MindeeHttp500Error;
  * Can include errors like RequestTimeout or GatewayTimeout.
  */
 class MindeeHttp504Error extends MindeeHttpError {
-    constructor(httpError, url, code) {
-        super(httpError, url, code);
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
         this.name = "MindeeHttp504Error";
     }
 }

package/src/http/index.d.ts

@@ -1,3 +1,4 @@
-export { Endpoint, EndpointResponse } from "./endpoint";
-export { STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, MindeeApi, } from "./mindeeApi";
+export { Endpoint } from "./endpoint";
+export { EndpointResponse } from "./baseEndpoint";
+export { STANDARD_API_OWNER, API_KEY_ENVVAR_NAME, ApiSettings, } from "./apiSettings";
 export { MindeeHttpError, MindeeHttp400Error, MindeeHttp401Error, MindeeHttp403Error, MindeeHttp404Error, MindeeHttp413Error, MindeeHttp429Error, MindeeHttp500Error, MindeeHttp504Error, handleError, } from "./error";

package/src/http/index.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleError = exports.MindeeHttp504Error = exports.MindeeHttp500Error = exports.MindeeHttp429Error = exports.MindeeHttp413Error = exports.MindeeHttp404Error = exports.MindeeHttp403Error = exports.MindeeHttp401Error = exports.MindeeHttp400Error = exports.MindeeHttpError = exports.MindeeApi = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.Endpoint = void 0;
+exports.handleError = exports.MindeeHttp504Error = exports.MindeeHttp500Error = exports.MindeeHttp429Error = exports.MindeeHttp413Error = exports.MindeeHttp404Error = exports.MindeeHttp403Error = exports.MindeeHttp401Error = exports.MindeeHttp400Error = exports.MindeeHttpError = exports.ApiSettings = exports.API_KEY_ENVVAR_NAME = exports.STANDARD_API_OWNER = exports.Endpoint = void 0;
 var endpoint_1 = require("./endpoint");
 Object.defineProperty(exports, "Endpoint", { enumerable: true, get: function () { return endpoint_1.Endpoint; } });
-var mindeeApi_1 = require("./mindeeApi");
-Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return mindeeApi_1.STANDARD_API_OWNER; } });
-Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return mindeeApi_1.API_KEY_ENVVAR_NAME; } });
-Object.defineProperty(exports, "MindeeApi", { enumerable: true, get: function () { return mindeeApi_1.MindeeApi; } });
+var apiSettings_1 = require("./apiSettings");
+Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: function () { return apiSettings_1.STANDARD_API_OWNER; } });
+Object.defineProperty(exports, "API_KEY_ENVVAR_NAME", { enumerable: true, get: function () { return apiSettings_1.API_KEY_ENVVAR_NAME; } });
+Object.defineProperty(exports, "ApiSettings", { enumerable: true, get: function () { return apiSettings_1.ApiSettings; } });
 var error_1 = require("./error");
 Object.defineProperty(exports, "MindeeHttpError", { enumerable: true, get: function () { return error_1.MindeeHttpError; } });
 Object.defineProperty(exports, "MindeeHttp400Error", { enumerable: true, get: function () { return error_1.MindeeHttp400Error; } });

package/src/input/base.d.ts

@@ -1,6 +1,10 @@
 /// <reference types="node" />
 import { PageOptions } from "./pageOptions";
-interface InputProps {
+/**
+ * @param {string} inputType - the type of input used in file ("base64", "path", "dummy").
+ *                             NB: dummy is only used for tests purposes
+ */
+interface InputConstructor {
     inputType: string;
 }
 export declare const INPUT_TYPE_STREAM = "stream";
@@ -19,12 +23,9 @@ export declare abstract class LocalInputSource extends InputSource {
     mimeType: string;
     fileObject: Buffer | string;
     /**
-     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-     *                             NB: dummy is only used for tests purposes
-     * @param {Boolean} cutPages
-     * NB: Because of async calls, init() should be called after creating the object
+     * @param {InputConstructor} constructor Constructor parameters.
      */
-    constructor({ inputType }: InputProps);
+    protected constructor({ inputType }: InputConstructor);
     isPdf(): boolean;
     checkMimetype(): Promise<string>;
     /**

package/src/input/base.js

@@ -62,10 +62,7 @@ class InputSource {
 exports.InputSource = InputSource;
 class LocalInputSource extends InputSource {
     /**
-     * @param {String} inputType - the type of input used in file ("base64", "path", "dummy").
-     *                             NB: dummy is only used for tests purposes
-     * @param {Boolean} cutPages
-     * NB: Because of async calls, init() should be called after creating the object
+     * @param {InputConstructor} constructor Constructor parameters.
      */
     constructor({ inputType }) {
         super();

package/src/parsing/common/apiResponse.d.ts

@@ -3,7 +3,7 @@ import { StringDict } from "./stringDict";
 /** Base wrapper for API requests.
  *
  * @category API Response
-*/
+ */
 export declare abstract class ApiResponse {
     /** Initial request sent to the API. */
     apiRequest: ApiRequest;

package/src/parsing/common/apiResponse.js

@@ -5,7 +5,7 @@ const apiRequest_1 = require("./apiRequest");
 /** Base wrapper for API requests.
  *
  * @category API Response
-*/
+ */
 class ApiResponse {
     /**
      * @param serverResponse JSON response from the server.

package/src/parsing/common/asyncPredictResponse.d.ts

@@ -6,7 +6,7 @@ import { Document } from "./document";
  *
  * @category API Response
  * @category Asynchronous
-*/
+ */
 export declare class Job {
     /** Timestamp noting the enqueueing of a document. */
     issuedAt: Date;
@@ -25,7 +25,7 @@ export declare class Job {
  *
  * @category API Response
  * @category Asynchronous
-*/
+ */
 export declare class AsyncPredictResponse<T extends Inference> extends ApiResponse {
     /** Job for a queue. */
     job: Job;
@@ -36,7 +36,7 @@ export declare class AsyncPredictResponse<T extends Inference> extends ApiRespon
     /**
      *
      * @param inferenceClass constructor signature for an inference.
-     * @param httpResponse raw http response.
+     * @param serverResponse raw http response.
      */
-    constructor(inferenceClass: new (httpResponse: StringDict) => T, httpResponse: StringDict);
+    constructor(inferenceClass: new (httpResponse: StringDict) => T, serverResponse: StringDict);
 }

package/src/parsing/common/asyncPredictResponse.js

@@ -7,7 +7,7 @@ const document_1 = require("./document");
  *
  * @category API Response
  * @category Asynchronous
-*/
+ */
 class Job {
     constructor(jsonResponse) {
         this.issuedAt = this.datetimeWithTimezone(jsonResponse["issued_at"]);
@@ -35,19 +35,19 @@ exports.Job = Job;
  *
  * @category API Response
  * @category Asynchronous
-*/
+ */
 class AsyncPredictResponse extends apiResponse_1.ApiResponse {
     /**
      *
      * @param inferenceClass constructor signature for an inference.
-     * @param httpResponse raw http response.
+     * @param serverResponse raw http response.
      */
-    constructor(inferenceClass, httpResponse) {
-        super(httpResponse);
-        this.job = new Job(httpResponse["job"]);
+    constructor(inferenceClass, serverResponse) {
+        super(serverResponse);
+        this.job = new Job(serverResponse["job"]);
         this.document =
-            httpResponse["document"] !== undefined
-                ? new document_1.Document(inferenceClass, httpResponse["document"])
+            serverResponse["document"] !== undefined
+                ? new document_1.Document(inferenceClass, serverResponse["document"])
                 : undefined;
     }
 }

package/src/parsing/common/document.d.ts

@@ -17,6 +17,8 @@ export declare class Document<T extends Inference> {
     extras?: Extras;
     /** Raw-text response for `allWords` parsing. */
     ocr?: Ocr;
+    /** Page number as sent back by the API. */
+    nPages: number;
     /**
      *
      * @param inferenceClass constructor signature for an inference.

package/src/parsing/common/document.js

@@ -32,6 +32,7 @@ class Document {
             });
             this.extras = new extras_1.Extras(extras);
         }
+        this.nPages = httpResponse["n_pages"];
     }
     /**
      * Default string representation.

package/src/parsing/common/feedback/feedbackResponse.d.ts

@@ -0,0 +1,15 @@
+import { ApiResponse } from "../apiResponse";
+import { StringDict } from "../stringDict";
+/**
+ * Wrapper for feedback response.
+ * @category API Response
+ * @category Synchronous
+ */
+export declare class FeedbackResponse extends ApiResponse {
+    /** A document feedback response. */
+    feedback: StringDict;
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse: StringDict);
+}

package/src/parsing/common/feedback/feedbackResponse.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackResponse = void 0;
+const apiResponse_1 = require("../apiResponse");
+/**
+ * Wrapper for feedback response.
+ * @category API Response
+ * @category Synchronous
+ */
+class FeedbackResponse extends apiResponse_1.ApiResponse {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        super(serverResponse);
+        this.feedback = serverResponse["feedback"];
+    }
+}
+exports.FeedbackResponse = FeedbackResponse;

package/src/parsing/common/index.d.ts

@@ -1,4 +1,5 @@
 export { Document } from "./document";
+export { FeedbackResponse } from "./feedback/feedbackResponse";
 export { OrientationField } from "./orientation";
 export { StringDict } from "./stringDict";
 export { Inference } from "./inference";

package/src/parsing/common/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.lineSeparator = exports.cleanOutString = exports.Page = exports.Prediction = exports.PredictResponse = exports.AsyncPredictResponse = exports.Inference = exports.OrientationField = exports.Document = void 0;
+exports.lineSeparator = exports.cleanOutString = exports.Page = exports.Prediction = exports.PredictResponse = exports.AsyncPredictResponse = exports.Inference = exports.OrientationField = exports.FeedbackResponse = exports.Document = void 0;
 var document_1 = require("./document");
 Object.defineProperty(exports, "Document", { enumerable: true, get: function () { return document_1.Document; } });
+var feedbackResponse_1 = require("./feedback/feedbackResponse");
+Object.defineProperty(exports, "FeedbackResponse", { enumerable: true, get: function () { return feedbackResponse_1.FeedbackResponse; } });
 var orientation_1 = require("./orientation");
 Object.defineProperty(exports, "OrientationField", { enumerable: true, get: function () { return orientation_1.OrientationField; } });
 var inference_1 = require("./inference");

package/src/parsing/common/inference.js

@@ -21,6 +21,14 @@ class Inference {
      * Default string representation.
      */
     toString() {
+        let pages = "";
+        if (this.pages.toString().length > 0) {
+            pages = `
+Page Predictions
+================
+
+${this.pages.map((e) => e.toString() || "").join("\n")}`;
+        }
         return `Inference
 #########
 :Product: ${this.product.name} v${this.product.version}
@@ -28,11 +36,7 @@ class Inference {
 
 Prediction
 ==========
-${this.prediction.toString().length === 0 ? "" : this.prediction.toString() + "\n"}
-Page Predictions
-================
-
-${this.pages.map((e) => e.toString() || "").join("\n")}`;
+${this.prediction.toString().length === 0 ? "" : this.prediction.toString() + "\n"}${pages}`;
     }
     /**
      * Takes in an input string and replaces line breaks with `\n`.

package/src/parsing/common/orientation.d.ts

@@ -11,10 +11,7 @@ export declare class OrientationField extends BaseField {
     /** Page id. */
     pageId: number;
     /**
-     * @param {Object} prediction - Prediction object from HTTP response
-     * @param {String} valueKey - Key to use in the prediction dict
-     * @param {Boolean} reconstructed - Is the object reconstructed (not extracted by the API)
-     * @param {Integer} pageId - Page ID for multi-page document
+     * @param {OrientationFieldConstructor} constructor Constructor parameters.
      */
     constructor({ prediction, valueKey, reconstructed, pageId, }: OrientationFieldConstructor);
     /**