mindee 4.36.2 → 5.0.0-alpha1

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

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

@@ -0,0 +1,49 @@
+import { ApiResponse } from "./apiResponse.js";
+import { Document } from "./document.js";
+/** Wrapper for asynchronous request queues. Holds information regarding a job (queue).
+ *
+ * @category API Response
+ * @category Asynchronous
+ */
+export class Job {
+    constructor(jsonResponse) {
+        this.issuedAt = datetimeWithTimezone(jsonResponse["issued_at"]);
+        if (jsonResponse["available_at"] !== undefined &&
+            jsonResponse["available_at"] !== null) {
+            this.availableAt = datetimeWithTimezone(jsonResponse["available_at"]);
+        }
+        this.id = jsonResponse["id"];
+        this.status = jsonResponse["status"];
+        if (this.availableAt !== undefined) {
+            this.milliSecsTaken =
+                this.availableAt.getTime() - this.issuedAt.getTime();
+        }
+    }
+}
+// Hideous thing to make sure dates sent back by the server are parsed correctly in UTC.
+export function datetimeWithTimezone(date) {
+    if (date.search(/\+[0-9]{2}:[0-9]{2}$/) === -1) {
+        date += "+00:00";
+    }
+    return new Date(date);
+}
+/** Wrapper for asynchronous jobs and parsing results.
+ *
+ * @category API Response
+ * @category Asynchronous
+ */
+export class AsyncPredictResponse extends ApiResponse {
+    /**
+     *
+     * @param inferenceClass constructor signature for an inference.
+     * @param serverResponse raw http response.
+     */
+    constructor(inferenceClass, serverResponse) {
+        super(serverResponse);
+        this.job = new Job(serverResponse["job"]);
+        this.document =
+            serverResponse["document"] !== undefined
+                ? new Document(inferenceClass, serverResponse["document"])
+                : undefined;
+    }
+}

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

@@ -0,0 +1,33 @@
+import { Extras } from "./extras/index.js";
+import { Inference } from "./inference.js";
+import { Ocr } from "./ocr.js";
+import { StringDict } from "../../../parsing/stringDict.js";
+/**
+ * Document prediction wrapper class. Holds the results of a parsed document.
+ * @typeParam T an extension of an `Inference`. Mandatory in order to properly create an inference.
+ */
+export declare class Document<T extends Inference> {
+    /** File name as sent back by the server. */
+    filename: string;
+    /** Result of the base inference. */
+    inference: T;
+    /** ID of the document as sent back by the server. */
+    id: string;
+    /** Potential `Extras` fields sent back along the prediction. */
+    extras?: Extras;
+    /** Raw-text response for `allWords` parsing. */
+    ocr?: Ocr;
+    /** Page number as sent back by the API. */
+    nPages: number;
+    /**
+     *
+     * @param inferenceClass constructor signature for an inference.
+     * @param httpResponse raw http response.
+     */
+    constructor(inferenceClass: new (httpResponse: StringDict) => T, httpResponse: StringDict);
+    /**
+     * Default string representation.
+     */
+    toString(): string;
+    private injectFullTextOcr;
+}

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

@@ -0,0 +1,71 @@
+import { CropperExtra, FullTextOcrExtra, Extras } from "./extras/index.js";
+import { Ocr } from "./ocr.js";
+import { RAGExtra } from "./extras/ragExtra.js";
+/**
+ * Document prediction wrapper class. Holds the results of a parsed document.
+ * @typeParam T an extension of an `Inference`. Mandatory in order to properly create an inference.
+ */
+export class Document {
+    /**
+     *
+     * @param inferenceClass constructor signature for an inference.
+     * @param httpResponse raw http response.
+     */
+    constructor(inferenceClass, httpResponse) {
+        this.id = httpResponse?.id ?? "";
+        this.filename = httpResponse?.name ?? "";
+        this.ocr = httpResponse.ocr && Object.keys(httpResponse.ocr).length > 0 ? new Ocr(httpResponse.ocr) : undefined;
+        this.inference = new inferenceClass(httpResponse["inference"]);
+        if (httpResponse["extras"] &&
+            Object.keys(httpResponse["extras"].length > 0)) {
+            const extras = {};
+            Object.entries(httpResponse["extras"]).forEach(([extraKey, extraValue]) => {
+                switch (extraKey) {
+                    case "cropper":
+                        extras["cropper"] = new CropperExtra(extraValue);
+                        break;
+                    case "full_text_ocr":
+                        extras["fullTextOcr"] = new FullTextOcrExtra(extraValue);
+                        break;
+                    case "rag":
+                        extras["rag"] = new RAGExtra(extraValue);
+                        break;
+                }
+            });
+            this.extras = new Extras(extras);
+        }
+        if (!this.extras || !("fullTextOcr" in this.extras) || this.extras["full_text_ocr"].toString().length === 0) {
+            this.injectFullTextOcr(httpResponse);
+        }
+        this.nPages = httpResponse["n_pages"];
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        return `########\nDocument\n########
+:Mindee ID: ${this.id}
+:Filename: ${this.filename}
+
+${this.inference?.toString()}`;
+    }
+    injectFullTextOcr(rawPrediction) {
+        if (rawPrediction["inference"]["pages"].length < 1 ||
+            !("extras" in rawPrediction["inference"]["pages"][0]) ||
+            rawPrediction["inference"]["pages"][0]["extras"].length < 1 ||
+            !("full_text_ocr" in rawPrediction["inference"]["pages"][0]["extras"]) ||
+            !rawPrediction["inference"]["pages"][0]["extras"]["full_text_ocr"] ||
+            !("content" in rawPrediction["inference"]["pages"][0]["extras"]["full_text_ocr"]) ||
+            !rawPrediction["inference"]["pages"][0]["extras"]["full_text_ocr"]["content"]) {
+            return;
+        }
+        const fullTextOcr = rawPrediction["inference"]["pages"].filter((e) => "extras" in e).map((e) => e["extras"]["full_text_ocr"]["content"]).join("\n");
+        const artificialTextObj = { "content": fullTextOcr.length > 0 ? fullTextOcr : "" };
+        if (!this.extras) {
+            this.extras = new Extras({ "fullTextOcr": new FullTextOcrExtra(artificialTextObj) });
+        }
+        else {
+            this.extras["fullTextOcr"] = new FullTextOcrExtra(artificialTextObj);
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+import { Inference } from "./inference.js";
+import { GeneratedV1Document } from "../../../v1/product/generated/generatedV1Document.js";
+import { ExecutionFile } from "./executionFile.js";
+import { StringDict } from "../../../parsing/stringDict.js";
+import { ExecutionPriority } from "./executionPriority.js";
+/**
+ * Representation of an execution for a workflow.
+ * @category Workflow
+ */
+export declare class Execution<T extends Inference> {
+    /** Identifier for the batch to which the execution belongs. */
+    batchName: string;
+    /** The time at which the execution started. */
+    createdAt: Date | null;
+    /** File representation within a workflow execution. */
+    file: ExecutionFile;
+    /** Identifier for the execution. */
+    id: string;
+    /** Deserialized inference object. */
+    inference: T | null;
+    /** Priority of the execution. */
+    priority: ExecutionPriority | null;
+    /** The time at which the file was tagged as reviewed. */
+    reviewedAt: Date | null;
+    /** The time at which the file was uploaded to a workflow. */
+    availableAt: Date | null;
+    /** Reviewed fields and values. */
+    reviewedPrediction: GeneratedV1Document | null;
+    /** Execution Status. */
+    status: string;
+    /** Execution type. */
+    type: string | null;
+    /** The time at which the file was uploaded to a workflow. */
+    uploadedAt: Date | null;
+    /** Identifier for the workflow. */
+    workflowId: string;
+    constructor(inferenceClass: new (serverResponse: StringDict) => T, jsonResponse: StringDict);
+}

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

@@ -0,0 +1,24 @@
+import { GeneratedV1Document } from "../../../v1/product/generated/generatedV1Document.js";
+import { parseDate } from "../../../parsing/dateParser.js";
+/**
+ * Representation of an execution for a workflow.
+ * @category Workflow
+ */
+export class Execution {
+    constructor(inferenceClass, jsonResponse) {
+        this.batchName = jsonResponse["batch_name"];
+        this.createdAt = parseDate(jsonResponse["created_at"]);
+        this.file = jsonResponse["file"];
+        this.id = jsonResponse["id"];
+        this.inference = jsonResponse["inference"] ? new inferenceClass(jsonResponse["inference"]) : null;
+        this.priority = jsonResponse["priority"];
+        this.reviewedAt = parseDate(jsonResponse["reviewed_at"]);
+        this.availableAt = parseDate(jsonResponse["available_at"]);
+        this.reviewedPrediction = jsonResponse["reviewed_prediction"] ?
+            new GeneratedV1Document(jsonResponse["reviewed_prediction"]) : null;
+        this.status = jsonResponse["status"];
+        this.type = jsonResponse["type"];
+        this.uploadedAt = parseDate(jsonResponse["uploaded_at"]);
+        this.workflowId = jsonResponse["workflow_id"];
+    }
+}

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

@@ -0,0 +1,12 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+/**
+ * Representation of an execution's file info.
+ * @category Workflow
+ */
+export declare class ExecutionFile {
+    /** File name. */
+    name: string | null;
+    /** Optional alias for the fil. */
+    alias: string | null;
+    constructor(jsonResponse: StringDict);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Representation of an execution's file info.
+ * @category Workflow
+ */
+export class ExecutionFile {
+    constructor(jsonResponse) {
+        this.name = jsonResponse["name"];
+        this.alias = jsonResponse["alias"];
+    }
+}

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

@@ -0,0 +1,6 @@
+export var ExecutionPriority;
+(function (ExecutionPriority) {
+    ExecutionPriority["low"] = "low";
+    ExecutionPriority["medium"] = "medium";
+    ExecutionPriority["high"] = "high";
+})(ExecutionPriority || (ExecutionPriority = {}));

package/src/v1/parsing/common/extras/cropperExtra.d.ts

@@ -0,0 +1,11 @@
+import { PositionField } from "../../../../v1/parsing/standard/position.js";
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { ExtraField } from "./extras.js";
+export declare class CropperExtra extends ExtraField {
+    cropping: PositionField[];
+    constructor(rawPrediction: StringDict, pageId?: number);
+    /**
+     * Default string representation.
+     */
+    toString(): string;
+}

package/src/v1/parsing/common/extras/cropperExtra.js

@@ -0,0 +1,26 @@
+import { PositionField } from "../../../../v1/parsing/standard/position.js";
+import { cleanOutString } from "../summaryHelper.js";
+import { ExtraField } from "./extras.js";
+export class CropperExtra extends ExtraField {
+    constructor(rawPrediction, pageId) {
+        super();
+        this.cropping = [];
+        if (rawPrediction["cropping"] !== undefined) {
+            rawPrediction["cropping"].forEach((crop) => {
+                this.cropping.push(new PositionField({
+                    prediction: crop,
+                    pageId: pageId,
+                }));
+            });
+        }
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        const cropping = this.cropping
+            .map((crop) => crop.toString())
+            .join("\n           ");
+        return cleanOutString(cropping);
+    }
+}

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

@@ -0,0 +1,17 @@
+export class ExtraField {
+}
+export class Extras {
+    constructor(fields) {
+        if (Object.keys(fields).length > 0) {
+            Object.keys(fields).forEach((name) => (this[name] = fields[name]));
+        }
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        return (Object.entries(this)
+            .map(([name, extraField]) => name + ":\n" + extraField.toString())
+            .join("\n") + "\n");
+    }
+}

package/src/v1/parsing/common/extras/fullTextOcrExtra.d.ts

@@ -0,0 +1,11 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { ExtraField } from "./extras.js";
+export declare class FullTextOcrExtra extends ExtraField {
+    content?: string;
+    languages?: string;
+    constructor(rawPrediction: StringDict);
+    /**
+     * Default string representation.
+     */
+    toString(): string;
+}

package/src/v1/parsing/common/extras/fullTextOcrExtra.js

@@ -0,0 +1,16 @@
+import { ExtraField } from "./extras.js";
+export class FullTextOcrExtra extends ExtraField {
+    constructor(rawPrediction) {
+        super();
+        if (rawPrediction["content"]) {
+            this.content = "content" in rawPrediction ? rawPrediction["content"] : "";
+            this.languages = "languages" in rawPrediction ? rawPrediction["languages"] : "";
+        }
+    }
+    /**
+     * Default string representation.
+     */
+    toString() {
+        return this.content !== undefined ? this.content : "";
+    }
+}

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

@@ -0,0 +1,4 @@
+export { CropperExtra } from "./cropperExtra.js";
+export { Extras, ExtraField } from "./extras.js";
+export { FullTextOcrExtra } from "./fullTextOcrExtra.js";
+export { RAGExtra } from "./ragExtra.js";

package/src/v1/parsing/common/extras/index.js

@@ -0,0 +1,4 @@
+export { CropperExtra } from "./cropperExtra.js";
+export { Extras, ExtraField } from "./extras.js";
+export { FullTextOcrExtra } from "./fullTextOcrExtra.js";
+export { RAGExtra } from "./ragExtra.js";

package/src/v1/parsing/common/extras/ragExtra.d.ts

@@ -0,0 +1,9 @@
+import { ExtraField } from "./extras.js";
+import { StringDict } from "../../../../parsing/stringDict.js";
+export declare class RAGExtra extends ExtraField {
+    /**
+     * ID reference of the document matched by the Retrieval-Augmented Generation.
+     */
+    matchingDocumentId?: string;
+    constructor(rawPrediction: StringDict);
+}

package/src/v1/parsing/common/extras/ragExtra.js

@@ -0,0 +1,9 @@
+import { ExtraField } from "./extras.js";
+export class RAGExtra extends ExtraField {
+    constructor(rawPrediction) {
+        super();
+        if (rawPrediction["matching_document_id"]) {
+            this.matchingDocumentId = rawPrediction["matching_document_id"];
+        }
+    }
+}

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

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

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

@@ -0,0 +1,15 @@
+import { ApiResponse } from "../apiResponse.js";
+/**
+ * Wrapper for feedback response.
+ * @category API Response
+ * @category Synchronous
+ */
+export class FeedbackResponse extends ApiResponse {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        super(serverResponse);
+        this.feedback = serverResponse["feedback"];
+    }
+}

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

@@ -0,0 +1,16 @@
+export { Document } from "./document.js";
+export { Execution } from "./execution.js";
+export { ExecutionFile } from "./executionFile.js";
+export { ExecutionPriority } from "./executionPriority.js";
+export { Inference } from "./inference.js";
+export { FeedbackResponse } from "./feedback/feedbackResponse.js";
+export { OrientationField } from "./orientation.js";
+export type { StringDict } from "../../../parsing/stringDict.js";
+export { AsyncPredictResponse } from "./asyncPredictResponse.js";
+export { PredictResponse } from "./predictResponse.js";
+export { Prediction } from "./prediction.js";
+export { Page } from "./page.js";
+export { cleanOutString, lineSeparator, floatToString, cleanSpecialChars } from "./summaryHelper.js";
+export * as extras from "./extras/index.js";
+export { parseDate } from "../../../parsing/dateParser.js";
+export { WorkflowResponse } from "./workflowResponse.js";