mindee 4.0.2 → 4.1.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # CHANGELOG
 
+## v4.1.0 - 2023-08-31
+### Changes
+* :boom: remove support for node versions <16
+* :sparkles: add support for auto-polling in asynchronous calls
+* :sparkles: update HTTP error management system
+* :sparkles: add possibility to access raw server response
+* :arrow_up: add support for node 20
+* :wrench: expose more internal tools
+* :memo: add better technical documentation
+* :recycle: remove deprecated examples
+* :recycle: update linting rules
+* :arrow_up: update testing library
+
+### Fixes
+* :bug: fix miscellaneous bugs related to http parsing issues
+
+
 ## v4.0.2 - 2023-08-24
 ### Changes
 * :recycle: updated technical documentation

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mindee",
-    "version": "4.0.2",
+    "version": "4.1.0",
     "description": "Mindee Client Library for Node.js",
     "main": "src/index.js",
     "bin": "bin/mindee.js",
@@ -23,7 +23,7 @@
         "CHANGELOG.md"
     ],
     "engines": {
-        "node": ">= 14"
+        "node": ">= 16"
     },
     "repository": {
         "type": "git",
@@ -46,9 +46,10 @@
         "@typescript-eslint/eslint-plugin": "^5.57.1",
         "@typescript-eslint/parser": "^5.57.1",
         "chai": "^4.3.7",
-        "eslint": "^8.32.0",
+        "eslint": "^8.47.0",
         "lint-staged": "^13.2.3",
         "mocha": "^10.1.0",
+        "nock": "^13.3.3",
         "ts-node": "^10.9.1",
         "typedoc": "~0.23",
         "typescript": "^5.0.4"

package/src/cli.js

@@ -193,8 +193,7 @@ function getPredictParams(options) {
     };
     return predictParams;
 }
-async function callParse(command, inputPath, options) {
-    const conf = getConfig(command);
+async function callParse(productClass, command, inputPath, options) {
     const mindeeClient = initClient(options);
     const predictParams = getPredictParams(options);
     const pageOptions = getPageOptions(options);
@@ -202,7 +201,7 @@ async function callParse(command, inputPath, options) {
     let response;
     if (command === COMMAND_CUSTOM) {
         const customEndpoint = mindeeClient.createEndpoint(options.endpoint, options.account, options.version);
-        response = await mindeeClient.parse(conf.docClass, inputSource, {
+        response = await mindeeClient.parse(productClass, inputSource, {
             endpoint: customEndpoint,
             pageOptions: pageOptions,
             allWords: predictParams.allWords,
@@ -210,7 +209,7 @@ async function callParse(command, inputPath, options) {
         });
     }
     else {
-        response = await mindeeClient.parse(conf.docClass, inputSource, {
+        response = await mindeeClient.parse(productClass, inputSource, {
             pageOptions: pageOptions,
             allWords: predictParams.allWords,
             cropper: predictParams.cropper,
@@ -218,8 +217,7 @@ async function callParse(command, inputPath, options) {
     }
     printResponse(response.document, options);
 }
-async function callEnqueue(command, inputPath, options) {
-    const conf = getConfig(command);
+async function callEnqueueAndParse(productClass, command, inputPath, options) {
     const mindeeClient = initClient(options);
     const predictParams = getPredictParams(options);
     const pageOptions = getPageOptions(options);
@@ -227,32 +225,30 @@ async function callEnqueue(command, inputPath, options) {
     let response;
     if (command === COMMAND_CUSTOM) {
         const customEndpoint = mindeeClient.createEndpoint(options.endpoint, options.account, options.version);
-        response = await mindeeClient.enqueue(conf.docClass, inputSource, {
+        response = await mindeeClient.enqueueAndParse(productClass, inputSource, {
             endpoint: customEndpoint,
             pageOptions: pageOptions,
             allWords: predictParams.allWords,
             cropper: predictParams.cropper,
+            initialDelaySec: 6,
+            delaySec: 3,
+            maxRetries: 10,
         });
     }
     else {
-        response = await mindeeClient.enqueue(conf.docClass, inputSource, {
+        response = await mindeeClient.enqueueAndParse(productClass, inputSource, {
             pageOptions: pageOptions,
             allWords: predictParams.allWords,
             cropper: predictParams.cropper,
+            initialDelaySec: 6,
+            delaySec: 3,
+            maxRetries: 10,
         });
-    }
-    console.log(response.job);
-}
-async function callParseQueued(command, queueId, options) {
-    const conf = getConfig(command);
-    const mindeeClient = initClient(options);
-    const response = await mindeeClient.parseQueued(conf.docClass, queueId);
-    if (response.document !== undefined) {
+        if (!response.document) {
+            throw Error("Document could not be retrieved");
+        }
         printResponse(response.document, options);
     }
-    else {
-        console.log(response.job);
-    }
 }
 function printResponse(document, options) {
     if (options.allWords) {
@@ -291,20 +287,11 @@ function addDisplayOptions(prog) {
     prog.option("-p, --pages", "show content of individual pages");
 }
 function routeSwitchboard(command, inputPath, allOptions) {
-    switch (command.parent?.name()) {
-        case "parse": {
-            return callParse(command.name(), inputPath, allOptions);
-        }
-        case "enqueue": {
-            return callEnqueue(command.name(), inputPath, allOptions);
-        }
-        case "parse-queued": {
-            return callParseQueued(command.name(), inputPath, allOptions);
-        }
-        default: {
-            throw new Error("Unhandled parent command.");
-        }
+    const docClass = getConfig(command.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) {
     if (prog.name() === COMMAND_CUSTOM) {
@@ -333,44 +320,27 @@ function addAction(prog) {
 function cli() {
     program.name("mindee");
     program.option("-d, --debug", "high verbosity mode");
-    const predict = program.command("parse").description("Parse synchronously.");
-    addMainOptions(predict);
-    const enqueue = program
-        .command("enqueue")
-        .description("Add to async parse queue.");
-    addMainOptions(enqueue);
-    const parseQueued = program
-        .command("parse-queued")
-        .description("Parse from async queue.");
-    addMainOptions(parseQueued);
     CLI_COMMAND_CONFIG.forEach((info, name) => {
-        if (info.sync) {
-            const prog = predict
-                .command(name)
-                .description(`Parse an ${info.displayName}.`);
-            if (name === COMMAND_CUSTOM) {
-                addCustomPostOptions(prog);
-            }
-            addDisplayOptions(prog);
-            addPostOptions(prog, info);
-            addAction(prog);
-        }
+        const prog = program.command(name);
+        prog.description(`${info.displayName} document`);
         if (info.async) {
-            const progEnqueue = enqueue
-                .command(name)
-                .description(`Add an ${info.displayName} to the queue.`);
-            if (name === COMMAND_CUSTOM) {
-                addCustomPostOptions(progEnqueue);
+            const asyncOpt = new commander_1.Option("-A, --async", "Call asynchronously");
+            if (info.sync) {
+                asyncOpt.default(false);
+            }
+            else {
+                asyncOpt.default(true);
+                asyncOpt.hideHelp();
             }
-            addPostOptions(progEnqueue, info);
-            addAction(progEnqueue);
-            const progParse = parseQueued
-                .command(name)
-                .description(`Parse an ${info.displayName} from the queue.`)
-                .argument("<doc_id>", "ID of the document");
-            addDisplayOptions(progParse);
-            addAction(progParse);
+            prog.addOption(asyncOpt);
+        }
+        if (name === COMMAND_CUSTOM) {
+            addCustomPostOptions(prog);
         }
+        addMainOptions(prog);
+        addDisplayOptions(prog);
+        addPostOptions(prog, info);
+        addAction(prog);
     });
     program.parse(process.argv);
 }

package/src/client.d.ts

@@ -28,6 +28,14 @@ export interface PredictOptions {
      */
     pageOptions?: PageOptions;
 }
+/**
+ * Asynchronous polling parameters.
+ */
+export interface AsyncOptions extends PredictOptions {
+    initialDelaySec: number;
+    delaySec: number;
+    maxRetries: number;
+}
 export interface ClientOptions {
     /** Your API key for all endpoints. */
     apiKey?: string;
@@ -55,7 +63,6 @@ export declare class Client {
      * @param productClass product class to use for calling the API and parsing the response.
      * @param inputSource 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.
@@ -66,7 +73,6 @@ export declare class Client {
      * @param productClass product class to use for calling  the API and parsing the response.
      * @param params parameters relating to prediction options.
      * @category Asynchronous
-     *
      * @returns a `Promise` containing the job (queue) corresponding to a document.
      */
     enqueue<T extends Inference>(productClass: new (httpResponse: StringDict) => T, inputSource: InputSource, params?: PredictOptions): Promise<AsyncPredictResponse<T>>;
@@ -78,11 +84,23 @@ export declare class Client {
      * @param params parameters relating to prediction options.
      * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
      * @category Asynchronous
-     *
      * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
      * parsing is complete.
      */
     parseQueued<T extends Inference>(productClass: new (httpResponse: StringDict) => T, queueId: string, params?: PredictOptions): Promise<AsyncPredictResponse<T>>;
+    /**
+     * 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.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource document to parse.
+     * @param asyncParams parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    enqueueAndParse<T extends Inference>(productClass: new (httpResponse: StringDict) => T, inputSource: InputSource, asyncParams?: AsyncOptions): Promise<AsyncPredictResponse<T>>;
     /**
      * Forces boolean coercion on truthy/falsy parameters.
      * @param param input parameter to check.

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_buildEndpoint, _Client_initializeOTSEndpoint, _Client_cleanAccountName, _Client_getEndpoint;
+var _Client_instances, _Client_validateAsyncParams, _Client_buildEndpoint, _Client_initializeOTSEndpoint, _Client_cleanAccountName, _Client_getEndpoint;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
 const input_1 = require("./input");
@@ -14,6 +14,7 @@ const handler_1 = require("./errors/handler");
 const logger_1 = require("./logger");
 const inference_1 = require("./parsing/common/inference");
 const product_1 = require("./product");
+const promises_1 = require("node:timers/promises");
 /**
  * Mindee Client class that centralizes most basic operations.
  *
@@ -43,7 +44,6 @@ class Client {
      * @param productClass product class to use for calling the API and parsing the response.
      * @param inputSource 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.
@@ -71,7 +71,6 @@ class Client {
      * @param productClass product class to use for calling  the API and parsing the response.
      * @param params parameters relating to prediction options.
      * @category Asynchronous
-     *
      * @returns a `Promise` containing the job (queue) corresponding to a document.
      */
     async enqueue(productClass, inputSource, params = {}) {
@@ -95,7 +94,6 @@ class Client {
      * @param params parameters relating to prediction options.
      * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
      * @category Asynchronous
-     *
      * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
      * parsing is complete.
      */
@@ -104,6 +102,54 @@ class Client {
         const docResponse = await endpoint.getQueuedDocument(queueId);
         return new common_1.AsyncPredictResponse(productClass, docResponse.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.
+     *
+     * @param productClass product class to use for calling the API and parsing the response.
+     * @param inputSource document to parse.
+     * @param asyncParams parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async enqueueAndParse(productClass, inputSource, asyncParams = {
+        endpoint: undefined,
+        allWords: undefined,
+        cropper: undefined,
+        pageOptions: undefined,
+        initialDelaySec: 6,
+        delaySec: 3,
+        maxRetries: 10,
+    }) {
+        __classPrivateFieldGet(this, _Client_instances, "m", _Client_validateAsyncParams).call(this, asyncParams);
+        const enqueueResponse = await this.enqueue(productClass, inputSource, asyncParams);
+        if (enqueueResponse.job.id === undefined || enqueueResponse.job.id.length === 0) {
+            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)(asyncParams.initialDelaySec * 1000);
+        let retryCounter = 1;
+        let pollResults;
+        pollResults = await this.parseQueued(productClass, queueId, asyncParams);
+        while (retryCounter < asyncParams.maxRetries) {
+            logger_1.logger.debug(`Polling server for parsing result with queueId: ${queueId}.
+Attempt n°${retryCounter}/${asyncParams.maxRetries}.
+Job status: ${pollResults.job.status}.`);
+            if (pollResults.job.status === "completed") {
+                break;
+            }
+            await (0, promises_1.setTimeout)(asyncParams.delaySec * 1000);
+            pollResults = await this.parseQueued(productClass, queueId, asyncParams);
+            retryCounter++;
+        }
+        if (pollResults.job.status !== "completed") {
+            throw Error(`Asynchronous parsing request timed out after ${asyncParams.delaySec * retryCounter} seconds`);
+        }
+        return pollResults;
+    }
     /**
      * Forces boolean coercion on truthy/falsy parameters.
      * @param param input parameter to check.
@@ -201,7 +247,17 @@ class Client {
     }
 }
 exports.Client = Client;
-_Client_instances = new WeakSet(), _Client_buildEndpoint = function _Client_buildEndpoint(endpointName, accountName, endpointVersion) {
+_Client_instances = new WeakSet(), _Client_validateAsyncParams = function _Client_validateAsyncParams(asyncParams) {
+    if (asyncParams.delaySec < 2) {
+        throw Error("Cannot set auto-parsing delay to less than 2 seconds.");
+    }
+    if (asyncParams.initialDelaySec < 4) {
+        throw Error("Cannot set initial parsing delay to less than 4 seconds.");
+    }
+    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({
         apiKey: this.apiKey,
         urlName: endpointName,

package/src/http/endpoint.d.ts

@@ -11,26 +11,55 @@ export interface EndpointResponse {
         [key: string]: any;
     };
 }
+/**
+ * Endpoint object class wrapper.
+ */
 export declare class Endpoint {
     #private;
+    /** URL of a product. */
     urlName: string;
+    /** Account owning the product. */
     owner: string;
+    /** Product's version, as a string. */
     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);
+    /**
+     * 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.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
     predict(params: {
         inputDoc: InputSource;
         includeWords: boolean;
         pageOptions?: PageOptions;
         cropper: boolean;
     }): 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.
+     * @category Asynchronous
+     * @returns a `Promise` containing queue data.
+     */
     predictAsync(params: {
         inputDoc: InputSource;
         includeWords: boolean;
         pageOptions?: PageOptions;
         cropper: boolean;
     }): 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.
+     * @category Asynchronous
+     * @returns a `Promise` containing the parsed result.
+     */
     getQueuedDocument(queueId: string): Promise<EndpointResponse>;
     /**
      * Send a file to a prediction API.
@@ -40,5 +69,12 @@ 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;
 }

package/src/http/endpoint.js

@@ -16,6 +16,9 @@ const form_data_1 = __importDefault(require("form-data"));
 const logger_1 = require("../logger");
 const base_1 = require("../input/base");
 const error_1 = require("./error");
+/**
+ * Endpoint object class wrapper.
+ */
 class Endpoint {
     constructor(urlName, owner, version, settings) {
         _Endpoint_instances.add(this);
@@ -25,6 +28,13 @@ class Endpoint {
         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.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
     async predict(params) {
         await params.inputDoc.init();
         if (params.pageOptions !== undefined) {
@@ -33,10 +43,17 @@ class Endpoint {
         const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.cropper);
         const statusCode = response.messageObj.statusCode;
         if (statusCode === undefined || statusCode >= 400) {
-            (0, error_1.handleError)(this.urlName, response, statusCode);
+            (0, error_1.handleError)(this.urlName, response, statusCode, response.messageObj?.statusMessage);
         }
         return response;
     }
+    /**
+     * Enqueues a prediction to the API.
+     * Throws an error if the server's response contains one.
+     * @param 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) {
@@ -45,17 +62,24 @@ class Endpoint {
         const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.cropper);
         const statusCode = response.messageObj.statusCode;
         if (statusCode === undefined || statusCode >= 400) {
-            (0, error_1.handleError)(this.urlName, response, statusCode);
+            (0, error_1.handleError)(this.urlName, response, statusCode, response.messageObj?.statusMessage);
         }
         return response;
     }
+    /**
+     * 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.
+     * @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 (queueStatusCode === undefined ||
             queueStatusCode < 200 ||
             queueStatusCode > 400) {
-            (0, error_1.handleError)(this.urlName, queueResponse, queueStatusCode);
+            (0, error_1.handleError)(this.urlName, queueResponse, queueStatusCode, queueResponse.messageObj?.statusMessage);
         }
         if (queueStatusCode === 302 &&
             queueResponse.messageObj.headers.location !== undefined) {
@@ -108,6 +132,13 @@ 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) {
@@ -140,7 +171,10 @@ class Endpoint {
                 catch (error) {
                     logger_1.logger.error("Could not parse the return as JSON.");
                     logger_1.logger.debug(responseBody);
-                    reject(error);
+                    resolve({
+                        messageObj: res,
+                        data: { reconstructedResponse: responseBody },
+                    });
                 }
             });
         });
@@ -151,7 +185,13 @@ class Endpoint {
     }
 }
 exports.Endpoint = Endpoint;
-_Endpoint_instances = new WeakSet(), _Endpoint_cutDocPages = async function _Endpoint_cutDocPages(inputDoc, pageOptions) {
+_Endpoint_instances = new WeakSet(), _Endpoint_cutDocPages = 
+/**
+ * Cuts a document's pages according to the given options.
+ * @param inputDoc input document.
+ * @param pageOptions page cutting options.
+ */
+async function _Endpoint_cutDocPages(inputDoc, pageOptions) {
     if (inputDoc instanceof base_1.LocalInputSource && inputDoc.isPdf()) {
         await inputDoc.cutPdf(pageOptions);
     }

package/src/http/error.d.ts

@@ -1,2 +1,67 @@
+import { MindeeError } from "../errors";
+import { StringDict } from "../parsing/common";
 import { EndpointResponse } from "./endpoint";
-export declare function handleError(url: string, response: EndpointResponse, statusCode?: number): void;
+export declare function handleError(url: 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.
+ */
+export declare class MindeeHttpError extends MindeeError {
+    /** Description of the error. */
+    message: string;
+    /** Additional details on the error. */
+    details: string | StringDict;
+    /** Standard HTTP error code. */
+    code?: number;
+    constructor(httpError: StringDict, url: string, code?: number);
+}
+/**
+ * Generic client errors.
+ * Can include errors like InvalidQuery.
+ */
+export declare class MindeeHttp400Error extends MindeeHttpError {
+    constructor(httpError: StringDict, url: string, code?: number);
+}
+/**
+ * Can include errors like NoTokenSet or InvalidToken.
+ */
+export declare class MindeeHttp401Error extends MindeeHttpError {
+    constructor(httpError: StringDict, url: 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);
+}
+export declare class MindeeHttp404Error extends MindeeHttpError {
+    constructor(httpError: StringDict, url: 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);
+}
+/**
+ * Usually contains 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);
+}
+/**
+ * Generic server errors.
+ */
+export declare class MindeeHttp500Error extends MindeeHttpError {
+    constructor(httpError: StringDict, url: 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);
+}