mindee 4.36.2 → 5.0.0-alpha1

package/src/v1/http/endpoint.js

@@ -0,0 +1,229 @@
+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 _Endpoint_instances, _Endpoint_predictReqPost, _Endpoint_predictAsyncReqPost, _Endpoint_documentQueueReqGet, _Endpoint_documentGetReq, _Endpoint_documentFeedbackPutReq;
+import { URLSearchParams } from "url";
+import { LocalInputSource } from "../../input/index.js";
+import { cutDocPages, sendRequestAndReadResponse } from "../../http/apiCore.js";
+import { handleError } from "./errors.js";
+import { isValidAsyncResponse, isValidSyncResponse } from "./responseValidation.js";
+/**
+ * Endpoint for a product (OTS or Custom).
+ */
+export class Endpoint {
+    constructor(urlName, owner, version, settings) {
+        _Endpoint_instances.add(this);
+        this.settings = settings;
+        this.urlRoot = `/v1/products/${owner}/${urlName}/v${version}`;
+        this.owner = owner;
+        this.urlName = urlName;
+        this.version = version;
+    }
+    /**
+     * Sends a document to the API and parses out the result.
+     * Throws an error if the server's response contains one.
+     * @param {PredictParams} 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) {
+            await cutDocPages(params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper);
+        if (!isValidSyncResponse(response)) {
+            handleError(this.urlName, response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    /**
+     * Enqueues a prediction to the API.
+     * Throws an error if the server's response contains one.
+     * @param {PredictParams} 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) {
+            await cutDocPages(params.inputDoc, params.pageOptions);
+        }
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_predictAsyncReqPost).call(this, params.inputDoc, params.includeWords, params.fullText, params.cropper, params.rag, params.workflowId);
+        if (!isValidAsyncResponse(response)) {
+            handleError(this.urlName, response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    extractStatusMessage(response) {
+        if (response.messageObj?.statusMessage !== undefined && response.messageObj?.statusMessage !== null) {
+            return response.messageObj?.statusMessage;
+        }
+        const errorDetail = response.data?.api_request?.error?.detail;
+        if (errorDetail) {
+            return JSON.stringify(errorDetail);
+        }
+        const errorMessage = response.data?.api_request?.error?.message;
+        if (errorMessage) {
+            return JSON.stringify(errorMessage);
+        }
+        return undefined;
+    }
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param queueId The document's ID in the queue.
+     * @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 (!isValidAsyncResponse(queueResponse)) {
+            handleError(this.urlName, queueResponse, this.extractStatusMessage(queueResponse));
+        }
+        if (queueStatusCode === 302 &&
+            queueResponse.messageObj.headers.location !== undefined) {
+            const docId = queueResponse.messageObj.headers.location.split("/").pop();
+            if (docId !== undefined) {
+                return await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, docId);
+            }
+        }
+        return queueResponse;
+    }
+    /**
+     * Send a feedback
+     * @param {string} documentId
+     */
+    async getDocument(documentId) {
+        const response = await __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_documentGetReq).call(this, documentId);
+        if (!isValidAsyncResponse(response)) {
+            handleError("document", response, this.extractStatusMessage(response));
+        }
+        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);
+        if (!isValidSyncResponse(response)) {
+            handleError("feedback", response, this.extractStatusMessage(response));
+        }
+        return response;
+    }
+    /**
+     * Send a file to a prediction API.
+     * @param input
+     * @param predictUrl
+     * @param includeWords
+     * @param fullText
+     * @param cropper
+     * @param rag
+     * @param workflowId
+     */
+    async sendFileForPrediction(input, predictUrl, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
+        const searchParams = new URLSearchParams();
+        if (cropper) {
+            searchParams.set("cropper", "true");
+        }
+        if (rag) {
+            searchParams.set("rag", "true");
+        }
+        if (fullText) {
+            searchParams.set("full_text_ocr", "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 (includeWords) {
+            form.set("include_mvision", "true");
+        }
+        let path;
+        if (workflowId === undefined) {
+            path = `${this.urlRoot}/${predictUrl}`;
+        }
+        else {
+            path = `/v1/workflows/${workflowId}/predict_async`;
+        }
+        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);
+    }
+}
+_Endpoint_instances = new WeakSet(), _Endpoint_predictReqPost = function _Endpoint_predictReqPost(input, includeWords = false, fullText = false, cropper = false) {
+    return this.sendFileForPrediction(input, "predict", includeWords, fullText, cropper);
+}, _Endpoint_predictAsyncReqPost = function _Endpoint_predictAsyncReqPost(
+/**
+ * Make a request to POST a document for async prediction.
+ * @param input
+ * @param includeWords
+ * @param fullText
+ * @param cropper
+ * @param rag
+ * @param workflowId
+ */
+input, includeWords = false, fullText = false, cropper = false, rag = false, workflowId = undefined) {
+    return this.sendFileForPrediction(input, "predict_async", includeWords, fullText, cropper, rag, workflowId);
+}, _Endpoint_documentQueueReqGet = 
+/**
+ * Make a request to GET the status of a document in the queue.
+ * @param queueId
+ */
+async function _Endpoint_documentQueueReqGet(queueId) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `${this.urlRoot}/documents/queue/${queueId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _Endpoint_documentGetReq = 
+/**
+ * Make a request to GET a document.
+ * @param documentId
+ */
+async function _Endpoint_documentGetReq(documentId) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `${this.urlRoot}/documents/${documentId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _Endpoint_documentFeedbackPutReq = 
+/**
+ * Make a request to PUT a document feedback.
+ * @param documentId
+ * @param feedback
+ */
+async function _Endpoint_documentFeedbackPutReq(documentId, feedback) {
+    const options = {
+        method: "PUT",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `/v1/documents/${documentId}/feedback`,
+        body: JSON.stringify(feedback),
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+};

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>;
+}