mindee 4.0.1 → 4.1.0

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) {
@@ -32,11 +42,18 @@ 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);
+        if (statusCode === undefined || statusCode >= 400) {
+            (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) {
@@ -44,18 +61,25 @@ 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);
+        if (statusCode === undefined || statusCode >= 400) {
+            (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) {
@@ -80,15 +104,13 @@ class Endpoint {
                 searchParams.append("cropper", "true");
             }
             const form = new form_data_1.default();
-            if (input instanceof base_1.LocalInputSource) {
-                if (input.fileObject instanceof Buffer) {
-                    form.append("document", input.fileObject, {
-                        filename: input.filename,
-                    });
-                }
-                else {
-                    form.append("document", input.fileObject);
-                }
+            if (input instanceof base_1.LocalInputSource && input.fileObject instanceof Buffer) {
+                form.append("document", input.fileObject, {
+                    filename: input.filename,
+                });
+            }
+            else {
+                form.append("document", input.fileObject);
             }
             if (includeWords) {
                 form.append("include_mvision", "true");
@@ -110,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) {
@@ -142,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 },
+                    });
                 }
             });
         });
@@ -153,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);
+}

package/src/http/error.js

@@ -1,9 +1,201 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleError = void 0;
+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, statusCode) {
-    const errorMessage = JSON.stringify(response.data, null, 2);
-    handler_1.errorHandler.throw(new Error(`${url} API ${statusCode} HTTP error: ${errorMessage}`));
+function handleError(url, response, code, serverError) {
+    if (code === undefined) {
+        throw new MindeeHttpError({ message: "Missing HTTP Error code.", details: response.data, undefined }, url);
+    }
+    let errorObj;
+    try {
+        //Regular instances where the returned error is in JSON format.
+        errorObj = response.data.api_request.error;
+    }
+    catch (err) {
+        //Rare instances where errors are returned as HTML instead of JSON.
+        if (!("reconstructedResponse" in response.data)) {
+            response.data.reconstructedResponse = "";
+        }
+        if (response.data.reconstructedResponse.includes("Maximum pdf pages")) {
+            errorObj = {
+                message: "TooManyPages",
+                details: "Maximum amount of pdf pages reached.",
+            };
+        }
+        else if (response.data.reconstructedResponse.includes("Max file size is")) {
+            errorObj = {
+                message: "FileTooLarge",
+                details: "Maximum file size reached.",
+            };
+        }
+        else if (response.data.reconstructedResponse.includes("Invalid file type")) {
+            errorObj = {
+                message: "InvalidFiletype",
+                details: "Invalid file type.",
+            };
+        }
+        else if (response.data.reconstructedResponse.includes("Gateway timeout")) {
+            errorObj = {
+                message: "RequestTimeout",
+                details: "Request timed out.",
+            };
+        }
+        else if (response.data.reconstructedResponse.includes("Bad gateway")) {
+            errorObj = {
+                message: "BadRequest",
+                details: "Bad Gateway",
+            };
+        }
+        else if (response.data.reconstructedResponse.includes("Too Many Requests")) {
+            errorObj = {
+                message: "TooManyRequests",
+                details: "Too Many Requests.",
+            };
+        }
+        else {
+            errorObj = {
+                message: "Unknown Server Error.",
+                details: response.data.reconstructedResponse,
+            };
+        }
+    }
+    if (serverError !== undefined &&
+        (!("message" in errorObj) ||
+            !errorObj.message ||
+            errorObj.message.length === 0)) {
+        errorObj.message = serverError;
+    }
+    let errorToThrow;
+    switch (code) {
+        case 400:
+            errorToThrow = new MindeeHttp400Error(errorObj, url, code);
+            break;
+        case 401:
+            errorToThrow = new MindeeHttp401Error(errorObj, url, code);
+            break;
+        case 403:
+            errorToThrow = new MindeeHttp403Error(errorObj, url, code);
+            break;
+        case 404:
+            errorToThrow = new MindeeHttp404Error(errorObj, url, code);
+            break;
+        case 413:
+            errorToThrow = new MindeeHttp413Error(errorObj, url, code);
+            break;
+        case 429:
+            errorToThrow = new MindeeHttp429Error(errorObj, url, code);
+            break;
+        case 500:
+            errorToThrow = new MindeeHttp500Error(errorObj, url, code);
+            break;
+        case 504:
+            errorToThrow = new MindeeHttp504Error(errorObj, url, code);
+            break;
+        default:
+            errorToThrow = new MindeeHttpError(errorObj, url, code);
+            break;
+    }
+    handler_1.errorHandler.throw(errorToThrow);
 }
 exports.handleError = handleError;
+/**
+ * `Error` wrapper for server (HTTP) errors.
+ * 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}`);
+        /** Description of the error. */
+        this.message = "";
+        /** Additional details on the error. */
+        this.details = "";
+        this.details = httpError.details;
+        this.message = httpError.message;
+        this.code = code;
+        this.name = "MindeeHttpError";
+    }
+}
+exports.MindeeHttpError = MindeeHttpError;
+/**
+ * Generic client errors.
+ * Can include errors like InvalidQuery.
+ */
+class MindeeHttp400Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp400Error";
+    }
+}
+exports.MindeeHttp400Error = MindeeHttp400Error;
+/**
+ * Can include errors like NoTokenSet or InvalidToken.
+ */
+class MindeeHttp401Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp401Error";
+    }
+}
+exports.MindeeHttp401Error = MindeeHttp401Error;
+/**
+ * Regular AccessForbidden error.
+ * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
+ */
+class MindeeHttp403Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp403Error";
+    }
+}
+exports.MindeeHttp403Error = MindeeHttp403Error;
+class MindeeHttp404Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp404Error";
+    }
+}
+exports.MindeeHttp404Error = MindeeHttp404Error;
+/**
+ * Rare error.
+ * Can occasionally happen when unusually large documents are passed.
+ */
+class MindeeHttp413Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp413Error";
+    }
+}
+exports.MindeeHttp413Error = MindeeHttp413Error;
+/**
+ * Usually contains TooManyRequests errors.
+ * 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);
+        this.name = "MindeeHttp429Error";
+    }
+}
+exports.MindeeHttp429Error = MindeeHttp429Error;
+/**
+ * Generic server errors.
+ */
+class MindeeHttp500Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp500Error";
+    }
+}
+exports.MindeeHttp500Error = MindeeHttp500Error;
+/**
+ * Miscellaneous server errors.
+ * Can include errors like RequestTimeout or GatewayTimeout.
+ */
+class MindeeHttp504Error extends MindeeHttpError {
+    constructor(httpError, url, code) {
+        super(httpError, url, code);
+        this.name = "MindeeHttp500Error";
+    }
+}
+exports.MindeeHttp504Error = MindeeHttp504Error;

package/src/http/index.d.ts

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

package/src/http/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleError = 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.MindeeApi = 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");
@@ -8,4 +8,13 @@ Object.defineProperty(exports, "STANDARD_API_OWNER", { enumerable: true, get: fu
 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 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; } });
+Object.defineProperty(exports, "MindeeHttp401Error", { enumerable: true, get: function () { return error_1.MindeeHttp401Error; } });
+Object.defineProperty(exports, "MindeeHttp403Error", { enumerable: true, get: function () { return error_1.MindeeHttp403Error; } });
+Object.defineProperty(exports, "MindeeHttp404Error", { enumerable: true, get: function () { return error_1.MindeeHttp404Error; } });
+Object.defineProperty(exports, "MindeeHttp413Error", { enumerable: true, get: function () { return error_1.MindeeHttp413Error; } });
+Object.defineProperty(exports, "MindeeHttp429Error", { enumerable: true, get: function () { return error_1.MindeeHttp429Error; } });
+Object.defineProperty(exports, "MindeeHttp500Error", { enumerable: true, get: function () { return error_1.MindeeHttp500Error; } });
+Object.defineProperty(exports, "MindeeHttp504Error", { enumerable: true, get: function () { return error_1.MindeeHttp504Error; } });
 Object.defineProperty(exports, "handleError", { enumerable: true, get: function () { return error_1.handleError; } });

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export * as product from "./product";
-export { Client, CustomConfigParams, PredictOptions } from "./client";
+export { Client, PredictOptions } from "./client";
 export { AsyncPredictResponse, PredictResponse, Document, Page, } from "./parsing/common";
 export { InputSource, PageOptionsOperation } from "./input";
+export * as internal from "./internal";

package/src/index.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PageOptionsOperation = exports.InputSource = exports.Page = exports.Document = exports.PredictResponse = exports.AsyncPredictResponse = exports.Client = exports.product = void 0;
+exports.internal = exports.PageOptionsOperation = exports.InputSource = exports.Page = exports.Document = exports.PredictResponse = exports.AsyncPredictResponse = exports.Client = exports.product = void 0;
 exports.product = __importStar(require("./product"));
 var client_1 = require("./client");
 Object.defineProperty(exports, "Client", { enumerable: true, get: function () { return client_1.Client; } });
@@ -35,3 +35,4 @@ Object.defineProperty(exports, "Page", { enumerable: true, get: function () { re
 var input_1 = require("./input");
 Object.defineProperty(exports, "InputSource", { enumerable: true, get: function () { return input_1.InputSource; } });
 Object.defineProperty(exports, "PageOptionsOperation", { enumerable: true, get: function () { return input_1.PageOptionsOperation; } });
+exports.internal = __importStar(require("./internal"));

package/src/input/base.d.ts

@@ -9,6 +9,7 @@ export declare const INPUT_TYPE_BYTES = "bytes";
 export declare const INPUT_TYPE_PATH = "path";
 export declare const INPUT_TYPE_BUFFER = "buffer";
 export declare abstract class InputSource {
+    fileObject: Buffer | string;
     init(): Promise<void>;
 }
 export declare abstract class LocalInputSource extends InputSource {

package/src/input/base.js

@@ -52,6 +52,9 @@ const ALLOWED_INPUT_TYPES = [
     exports.INPUT_TYPE_BUFFER,
 ];
 class InputSource {
+    constructor() {
+        this.fileObject = "";
+    }
     async init() {
         throw new Error("not Implemented");
     }

package/src/input/pageOptions.d.ts

@@ -1,3 +1,4 @@
+/** Options to pass to the `parse` method for cutting multi-page documents. */
 export interface PageOptions {
     /**
      * Zero-based list of page indexes.
@@ -14,7 +15,10 @@ export interface PageOptions {
      */
     onMinPages: number;
 }
+/** Operation to apply on the document, given the page indexes specified. */
 export declare enum PageOptionsOperation {
+    /** Only keep pages matching the provided indexes. */
     KeepOnly = "KEEP_ONLY",
+    /** Remove pages matching the provided indexes. */
     Remove = "REMOVE"
 }

package/src/input/pageOptions.js

@@ -1,8 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PageOptionsOperation = void 0;
+/** Operation to apply on the document, given the page indexes specified. */
 var PageOptionsOperation;
 (function (PageOptionsOperation) {
+    /** Only keep pages matching the provided indexes. */
     PageOptionsOperation["KeepOnly"] = "KEEP_ONLY";
+    /** Remove pages matching the provided indexes. */
     PageOptionsOperation["Remove"] = "REMOVE";
 })(PageOptionsOperation = exports.PageOptionsOperation || (exports.PageOptionsOperation = {}));

package/src/input/sources.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 import { Readable } from "stream";
 import { Buffer } from "buffer";
-import { LocalInputSource } from "./base";
+import { LocalInputSource, InputSource } from "./base";
 interface PathInputProps {
     inputPath: string;
 }
@@ -43,9 +43,8 @@ export declare class BytesInput extends LocalInputSource {
     constructor({ inputBytes, filename }: BytesInputProps);
     init(): Promise<void>;
 }
-export declare class UrlInput {
+export declare class UrlInput extends InputSource {
     private readonly url;
-    fileObject: string;
     constructor({ url }: {
         url: string;
     });

package/src/input/sources.js

@@ -106,8 +106,9 @@ exports.BytesInput = BytesInput;
 //
 // URL
 //
-class UrlInput {
+class UrlInput extends base_1.InputSource {
     constructor({ url }) {
+        super();
         this.url = url;
     }
     async init() {

package/src/internal.d.ts

@@ -0,0 +1,5 @@
+export * as product from "./product/internal";
+export * as parsing from "./parsing";
+export * as pdf from "./pdf";
+export * as geometry from "./geometry";
+export * as http from "./http";

package/src/internal.js

@@ -0,0 +1,31 @@
+"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.http = exports.geometry = exports.pdf = exports.parsing = exports.product = void 0;
+exports.product = __importStar(require("./product/internal"));
+exports.parsing = __importStar(require("./parsing"));
+exports.pdf = __importStar(require("./pdf"));
+exports.geometry = __importStar(require("./geometry"));
+exports.http = __importStar(require("./http"));

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

@@ -1,10 +1,19 @@
 import { StringDict } from "./stringDict";
+/**
+ * Holds the information relating to an API HTTP request.
+ *
+ * @category API Response
+ */
 export declare class ApiRequest {
+    /**  An object detailing the error. */
     error: StringDict;
+    /** Target of the request. */
     resources: string[];
+    /** Status of the request. Either "failure" or "success". */
     status: "failure" | "success";
     /** HTTP status code */
     statusCode: number;
+    /** URL of the request. */
     url: string;
     constructor(serverResponse: StringDict);
 }