mindee 4.36.3 → 5.0.0-alpha1

package/src/v1/http/errors.d.ts

@@ -0,0 +1,67 @@
+import { MindeeError } from "../../errors/index.js";
+import { StringDict } from "../../parsing/stringDict.js";
+import { BaseHttpResponse } from "../../http/apiCore.js";
+export declare function handleError(urlName: string, response: BaseHttpResponse, serverError?: string): void;
+/**
+ * `Error` wrapper for server (HTTP) errors.
+ * Is used when an error is lacking a handled error code.
+ */
+export declare class MindeeHttpErrorV1 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, urlName: string, code?: number);
+}
+/**
+ * Generic client errors.
+ * Can include errors like InvalidQuery.
+ */
+export declare class MindeeHttp400Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+/**
+ * Can include errors like NoTokenSet or InvalidToken.
+ */
+export declare class MindeeHttp401Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+/**
+ * Regular AccessForbidden error.
+ * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
+ */
+export declare class MindeeHttp403Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+export declare class MindeeHttp404Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+/**
+ * Rare error.
+ * Can occasionally happen when unusually large documents are passed.
+ */
+export declare class MindeeHttp413Error extends MindeeHttpErrorV1 {
+    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 MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+/**
+ * Generic server errors.
+ */
+export declare class MindeeHttp500Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}
+/**
+ * Miscellaneous server errors.
+ * Can include errors like RequestTimeout or GatewayTimeout.
+ */
+export declare class MindeeHttp504Error extends MindeeHttpErrorV1 {
+    constructor(httpError: StringDict, urlName: string, code?: number);
+}

package/src/v1/http/errors.js

@@ -0,0 +1,198 @@
+import { MindeeError } from "../../errors/index.js";
+import { errorHandler } from "../../errors/handler.js";
+export function handleError(urlName, response, serverError) {
+    let code;
+    try {
+        if (response.data.api_request["status_code"] === 200 && response.data?.job?.error?.code) {
+            code = 500;
+            response.data.api_request.error = response.data.job.error;
+        }
+        else if (response.data) {
+            code = response.data.api_request["status_code"];
+        }
+    }
+    catch {
+        code = 500;
+    }
+    let errorObj;
+    try {
+        //Regular instances where the returned error is in JSON format.
+        errorObj = response.data.api_request.error;
+    }
+    catch {
+        //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, urlName, code);
+            break;
+        case 401:
+            errorToThrow = new MindeeHttp401Error(errorObj, urlName, code);
+            break;
+        case 403:
+            errorToThrow = new MindeeHttp403Error(errorObj, urlName, code);
+            break;
+        case 404:
+            errorToThrow = new MindeeHttp404Error(errorObj, urlName, code);
+            break;
+        case 413:
+            errorToThrow = new MindeeHttp413Error(errorObj, urlName, code);
+            break;
+        case 429:
+            errorToThrow = new MindeeHttp429Error(errorObj, urlName, code);
+            break;
+        case 500:
+            errorToThrow = new MindeeHttp500Error(errorObj, urlName, code);
+            break;
+        case 504:
+            errorToThrow = new MindeeHttp504Error(errorObj, urlName, code);
+            break;
+        default:
+            errorToThrow = new MindeeHttpErrorV1(errorObj, urlName, code);
+            break;
+    }
+    errorHandler.throw(errorToThrow);
+}
+/**
+ * `Error` wrapper for server (HTTP) errors.
+ * Is used when an error is lacking a handled error code.
+ */
+export class MindeeHttpErrorV1 extends MindeeError {
+    constructor(httpError, urlName, code) {
+        super(`${urlName} 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";
+    }
+}
+/**
+ * Generic client errors.
+ * Can include errors like InvalidQuery.
+ */
+export class MindeeHttp400Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp400Error";
+    }
+}
+/**
+ * Can include errors like NoTokenSet or InvalidToken.
+ */
+export class MindeeHttp401Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp401Error";
+    }
+}
+/**
+ * Regular AccessForbidden error.
+ * Can also include errors like PlanLimitReached, AsyncRequestDisallowed or SyncRequestDisallowed.
+ */
+export class MindeeHttp403Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp403Error";
+    }
+}
+export class MindeeHttp404Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp404Error";
+    }
+}
+/**
+ * Rare error.
+ * Can occasionally happen when unusually large documents are passed.
+ */
+export class MindeeHttp413Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp413Error";
+    }
+}
+/**
+ * Usually corresponds to TooManyRequests errors.
+ * Arises whenever too many calls to the API are made in quick succession.
+ */
+export class MindeeHttp429Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp429Error";
+    }
+}
+/**
+ * Generic server errors.
+ */
+export class MindeeHttp500Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp500Error";
+    }
+}
+/**
+ * Miscellaneous server errors.
+ * Can include errors like RequestTimeout or GatewayTimeout.
+ */
+export class MindeeHttp504Error extends MindeeHttpErrorV1 {
+    constructor(httpError, urlName, code) {
+        super(httpError, urlName, code);
+        this.name = "MindeeHttp504Error";
+    }
+}

package/src/v1/http/httpParams.d.ts

@@ -0,0 +1,19 @@
+import { InputSource, PageOptions } from "../../input/index.js";
+import { ExecutionPriority } from "../../v1/parsing/common/index.js";
+interface HTTPParams {
+    inputDoc: InputSource;
+    fullText: boolean;
+    pageOptions?: PageOptions;
+    rag?: boolean;
+}
+export interface PredictParams extends HTTPParams {
+    includeWords: boolean;
+    cropper: boolean;
+    workflowId?: string;
+}
+export interface WorkflowParams extends HTTPParams {
+    alias?: string;
+    priority?: ExecutionPriority;
+    publicUrl?: string;
+}
+export {};

package/src/v1/http/httpParams.js

@@ -0,0 +1 @@
+export {};

package/src/v1/http/index.d.ts

@@ -0,0 +1,5 @@
+export { Endpoint } from "./endpoint.js";
+export { STANDARD_API_OWNER, ApiSettingsV1, } from "./apiSettingsV1.js";
+export { MindeeHttpErrorV1, MindeeHttp400Error, MindeeHttp401Error, MindeeHttp403Error, MindeeHttp404Error, MindeeHttp413Error, MindeeHttp429Error, MindeeHttp500Error, MindeeHttp504Error, handleError, } from "./errors.js";
+export { WorkflowEndpoint } from "./workflowEndpoint.js";
+export type { PredictParams, WorkflowParams } from "./httpParams.js";

package/src/v1/http/index.js

@@ -0,0 +1,4 @@
+export { Endpoint } from "./endpoint.js";
+export { STANDARD_API_OWNER, ApiSettingsV1, } from "./apiSettingsV1.js";
+export { MindeeHttpErrorV1, MindeeHttp400Error, MindeeHttp401Error, MindeeHttp403Error, MindeeHttp404Error, MindeeHttp413Error, MindeeHttp429Error, MindeeHttp500Error, MindeeHttp504Error, handleError, } from "./errors.js";
+export { WorkflowEndpoint } from "./workflowEndpoint.js";

package/src/v1/http/responseValidation.d.ts

@@ -0,0 +1,23 @@
+import { BaseHttpResponse } from "../../http/apiCore.js";
+/**
+ * Checks if the synchronous response is valid. Returns True if the response is valid.
+ *
+ * @param response an endpoint response object.
+ * @returns bool
+ */
+export declare function isValidSyncResponse(response: BaseHttpResponse): boolean;
+/**
+ * Checks if the asynchronous response is valid. Also checks if it is a valid synchronous response.
+ * Returns True if the response is valid.
+ *
+ * @param response an endpoint response object.
+ * @returns bool
+ */
+export declare function isValidAsyncResponse(response: BaseHttpResponse): boolean;
+/**
+ * Checks and correct the response object depending on the possible kinds of returns.
+ *
+ * @param response an endpoint response object.
+ * @returns EndpointResponse Returns the job error if the error is due to parsing, returns the http error otherwise.
+ */
+export declare function cleanRequestData(response: BaseHttpResponse): BaseHttpResponse;

package/src/v1/http/responseValidation.js

@@ -0,0 +1,73 @@
+/**
+ * Checks if the synchronous response is valid. Returns True if the response is valid.
+ *
+ * @param response an endpoint response object.
+ * @returns bool
+ */
+export function isValidSyncResponse(response) {
+    if (!response.messageObj || !response.messageObj.statusCode) {
+        return false;
+    }
+    if (response.data &&
+        response.data["api_request"] &&
+        response.data["api_request"]["status_code"] &&
+        response.data["api_request"]["status_code"] > 399) {
+        return false;
+    }
+    return !(isNaN(response.messageObj.statusCode) ||
+        parseInt(response.messageObj.statusCode.toString()) < 200 ||
+        parseInt(response.messageObj.statusCode.toString()) > 302);
+}
+/**
+ * Checks if the asynchronous response is valid. Also checks if it is a valid synchronous response.
+ * Returns True if the response is valid.
+ *
+ * @param response an endpoint response object.
+ * @returns bool
+ */
+export function isValidAsyncResponse(response) {
+    if (!isValidSyncResponse(response)) {
+        return false;
+    }
+    if (response.messageObj.statusCode) {
+        if (response.messageObj.statusCode >= 300 && response.messageObj.statusCode <= 302) {
+            // Skip next check for redirections as the final payload will be checked anyway.
+            return true;
+        }
+        else if (response.messageObj.statusCode < 200 || response.messageObj.statusCode > 302) {
+            return false;
+        }
+    }
+    if (!response.data["job"]) {
+        return false;
+    }
+    return !(response.data["job"] &&
+        response.data["job"]["error"] &&
+        Object.keys(response.data["job"]["error"]).length > 0);
+}
+/**
+ * Checks and correct the response object depending on the possible kinds of returns.
+ *
+ * @param response an endpoint response object.
+ * @returns EndpointResponse Returns the job error if the error is due to parsing, returns the http error otherwise.
+ */
+export function cleanRequestData(response) {
+    if (response.messageObj &&
+        response.messageObj.statusCode &&
+        (response.messageObj.statusCode < 200 ||
+            response.messageObj.statusCode > 302)) {
+        return response;
+    }
+    if (response.data) {
+        if (response.data["api_request"] &&
+            response.data["api_request"]["status_code"] &&
+            parseInt(response.data["api_request"]["status_code"].toString()) > 399) {
+            response.messageObj.statusCode = parseInt(response.data["api_request"]["status_code"].toString());
+        }
+        if (response.data["job"] && response.data["job"]["error"] &&
+            Object.keys(response.data["job"]["error"]).length > 0) {
+            response.messageObj.statusCode = 500;
+        }
+    }
+    return response;
+}

package/src/v1/http/workflowEndpoint.d.ts

@@ -0,0 +1,34 @@
+import { InputSource } from "../../input/index.js";
+import { ExecutionPriority } from "../../v1/parsing/common/index.js";
+import { BaseHttpResponse } from "../../http/apiCore.js";
+import { ApiSettingsV1 } from "./apiSettingsV1.js";
+import { WorkflowParams } from "./httpParams.js";
+/**
+ * Endpoint for a workflow.
+ */
+export declare class WorkflowEndpoint {
+    #private;
+    /** Settings relating to the API. */
+    settings: ApiSettingsV1;
+    /** Root of the URL for API calls. */
+    urlRoot: string;
+    constructor(settings: ApiSettingsV1, workflowId: string);
+    /**
+     * Sends a document to a workflow execution.
+     * Throws an error if the server's response contains one.
+     * @param {WorkflowParams} params parameters relating to prediction options.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    executeWorkflow(params: WorkflowParams): Promise<BaseHttpResponse>;
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param alias
+     * @param priority
+     * @param fullText
+     * @param publicUrl
+     * @param rag
+     */
+    protected sendFileForPrediction(input: InputSource, alias?: string | null, priority?: ExecutionPriority | null, fullText?: boolean, publicUrl?: string | null, rag?: boolean | null): Promise<BaseHttpResponse>;
+}

package/src/v1/http/workflowEndpoint.js

@@ -0,0 +1,89 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _WorkflowEndpoint_instances, _WorkflowEndpoint_workflowReqPost;
+import { URLSearchParams } from "url";
+import { LocalInputSource } from "../../input/index.js";
+import { cutDocPages, sendRequestAndReadResponse } from "../../http/apiCore.js";
+import { handleError } from "./errors.js";
+import { isValidSyncResponse } from "./responseValidation.js";
+/**
+ * Endpoint for a workflow.
+ */
+export class WorkflowEndpoint {
+    constructor(settings, workflowId) {
+        _WorkflowEndpoint_instances.add(this);
+        this.settings = settings;
+        this.urlRoot = `/v1/workflows/${workflowId}/executions`;
+    }
+    /**
+     * Sends a document to a workflow execution.
+     * Throws an error if the server's response contains one.
+     * @param {WorkflowParams} params parameters relating to prediction options.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async executeWorkflow(params) {
+        await params.inputDoc.init();
+        if (params.pageOptions !== undefined) {
+            await cutDocPages(params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _WorkflowEndpoint_instances, "m", _WorkflowEndpoint_workflowReqPost).call(this, params);
+        if (!isValidSyncResponse(response)) {
+            handleError(this.urlRoot, response, response.messageObj?.statusMessage);
+        }
+        return response;
+    }
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param alias
+     * @param priority
+     * @param fullText
+     * @param publicUrl
+     * @param rag
+     */
+    async sendFileForPrediction(input, alias = null, priority = null, fullText = false, publicUrl = null, rag = null) {
+        const searchParams = new URLSearchParams();
+        if (fullText) {
+            searchParams.set("full_text_ocr", "true");
+        }
+        if (rag) {
+            searchParams.set("rag", "true");
+        }
+        const form = new FormData();
+        if (input instanceof LocalInputSource && input.fileObject instanceof Buffer) {
+            form.set("document", new Blob([input.fileObject]), input.filename);
+        }
+        else {
+            form.set("document", input.fileObject);
+        }
+        if (alias) {
+            form.set("alias", alias);
+        }
+        if (publicUrl) {
+            form.set("public_url", publicUrl);
+        }
+        if (priority) {
+            form.set("priority", priority.toString());
+        }
+        let path = this.urlRoot;
+        if (searchParams.toString().length > 0) {
+            path += `?${searchParams}`;
+        }
+        const options = {
+            method: "POST",
+            headers: this.settings.baseHeaders,
+            hostname: this.settings.hostname,
+            path: path,
+            timeout: this.settings.timeout,
+            body: form,
+        };
+        return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+    }
+}
+_WorkflowEndpoint_instances = new WeakSet(), _WorkflowEndpoint_workflowReqPost = function _WorkflowEndpoint_workflowReqPost(params) {
+    return this.sendFileForPrediction(params.inputDoc, params.alias, params.priority, params.fullText, params.publicUrl, params.rag);
+};

package/src/v1/index.d.ts

@@ -0,0 +1,8 @@
+export * as extraction from "./extraction/index.js";
+export * as http from "./http/index.js";
+export * as parsing from "./parsing/index.js";
+export * as product from "./product/index.js";
+export { LocalResponse } from "./parsing/localResponse.js";
+export { Client } from "./client.js";
+export type { OptionalAsyncOptions, PredictOptions, WorkflowOptions } from "./client.js";
+export { AsyncPredictResponse, PredictResponse, Inference, Prediction, Document, Page, } from "./parsing/common/index.js";

package/src/v1/index.js

@@ -0,0 +1,7 @@
+export * as extraction from "./extraction/index.js";
+export * as http from "./http/index.js";
+export * as parsing from "./parsing/index.js";
+export * as product from "./product/index.js";
+export { LocalResponse } from "./parsing/localResponse.js";
+export { Client } from "./client.js";
+export { AsyncPredictResponse, PredictResponse, Inference, Prediction, Document, Page, } from "./parsing/common/index.js";

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

@@ -0,0 +1,19 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+/**
+ * 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);
+}

package/src/v1/parsing/common/apiRequest.js

@@ -0,0 +1,14 @@
+/**
+ * Holds the information relating to an API HTTP request.
+ *
+ * @category API Response
+ */
+export class ApiRequest {
+    constructor(serverResponse) {
+        this.error = serverResponse["error"];
+        this.resources = serverResponse["resources"];
+        this.status = serverResponse["status"];
+        this.statusCode = serverResponse["status_code"];
+        this.url = serverResponse["url"];
+    }
+}

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

@@ -0,0 +1,21 @@
+import { ApiRequest } from "./apiRequest.js";
+import { StringDict } from "../../../parsing/stringDict.js";
+/** Base wrapper for API requests.
+ *
+ * @category API Response
+ */
+export declare abstract class ApiResponse {
+    /** Initial request sent to the API. */
+    apiRequest: ApiRequest;
+    /** Raw text representation of the API's response. */
+    private readonly rawHttp;
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse: StringDict);
+    /**
+     * Raw HTTP request sent from server, as a JSON-like structure
+     * @returns The HTTP request
+     */
+    getRawHttp(): StringDict;
+}

package/src/v1/parsing/common/apiResponse.js

@@ -0,0 +1,21 @@
+import { ApiRequest } from "./apiRequest.js";
+/** Base wrapper for API requests.
+ *
+ * @category API Response
+ */
+export class ApiResponse {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        this.apiRequest = new ApiRequest(serverResponse["api_request"]);
+        this.rawHttp = serverResponse;
+    }
+    /**
+     * Raw HTTP request sent from server, as a JSON-like structure
+     * @returns The HTTP request
+     */
+    getRawHttp() {
+        return this.rawHttp;
+    }
+}

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

@@ -0,0 +1,44 @@
+import { ApiResponse } from "./apiResponse.js";
+import { StringDict } from "../../../parsing/stringDict.js";
+import { Inference } from "./inference.js";
+import { Document } from "./document.js";
+/** Wrapper for asynchronous request queues. Holds information regarding a job (queue).
+ *
+ * @category API Response
+ * @category Asynchronous
+ */
+export declare class Job {
+    /** Timestamp noting the enqueueing of a document. */
+    issuedAt: Date;
+    /** Timestamp noting the availability of a prediction for an enqueued document. */
+    availableAt?: Date;
+    /** Information about an error that occurred during the job processing. */
+    error?: StringDict;
+    /** ID of the job. */
+    id: string;
+    /** Status of the job. */
+    status?: "waiting" | "processing" | "completed" | "failed";
+    /** The time taken to process the job, in milliseconds. */
+    milliSecsTaken?: number;
+    constructor(jsonResponse: StringDict);
+}
+export declare function datetimeWithTimezone(date: string): Date;
+/** Wrapper for asynchronous jobs and parsing results.
+ *
+ * @category API Response
+ * @category Asynchronous
+ */
+export declare class AsyncPredictResponse<T extends Inference> extends ApiResponse {
+    /** Job for a queue. */
+    job: Job;
+    /** Prediction for an asynchronous request. Will not be available so long as the job is not
+     * `completed`.
+     */
+    document?: Document<T>;
+    /**
+     *
+     * @param inferenceClass constructor signature for an inference.
+     * @param serverResponse raw http response.
+     */
+    constructor(inferenceClass: new (httpResponse: StringDict) => T, serverResponse: StringDict);
+}