mindee 4.36.3 → 5.0.0-alpha2

package/src/v2/parsing/error/index.js

@@ -0,0 +1,2 @@
+export { ErrorResponse } from "./errorResponse.js";
+export { ErrorItem } from "./errorItem.js";

package/src/v2/parsing/index.d.ts

@@ -0,0 +1,8 @@
+export { ErrorResponse, ErrorItem, } from "./error/index.js";
+export type { ErrorDetails } from "./error/index.js";
+export { Job, JobResponse, JobWebhook } from "./job/index.js";
+export { BaseInference, InferenceFile, InferenceModel, } from "./inference/index.js";
+export { LocalResponse } from "./localResponse.js";
+export { BaseResponse } from "./baseResponse.js";
+export type { ResponseConstructor } from "./baseResponse.js";
+export * as field from "./inference/field/index.js";

package/src/v2/parsing/index.js

@@ -0,0 +1,6 @@
+export { ErrorResponse, ErrorItem, } from "./error/index.js";
+export { Job, JobResponse, JobWebhook } from "./job/index.js";
+export { BaseInference, InferenceFile, InferenceModel, } from "./inference/index.js";
+export { LocalResponse } from "./localResponse.js";
+export { BaseResponse } from "./baseResponse.js";
+export * as field from "./inference/field/index.js";

package/src/v2/parsing/inference/baseInference.d.ts

@@ -0,0 +1,19 @@
+import { InferenceModel } from "./inferenceModel.js";
+import { InferenceFile } from "./inferenceFile.js";
+import { StringDict } from "../../../parsing/index.js";
+export declare abstract class BaseInference {
+    /**
+     * Model info for the inference.
+     */
+    model: InferenceModel;
+    /**
+     * File info for the inference.
+     */
+    file: InferenceFile;
+    /**
+     * ID of the inference.
+     */
+    id: string;
+    protected constructor(serverResponse: StringDict);
+    toString(): string;
+}

package/src/v2/parsing/inference/baseInference.js

@@ -0,0 +1,15 @@
+import { InferenceModel } from "./inferenceModel.js";
+import { InferenceFile } from "./inferenceFile.js";
+export class BaseInference {
+    constructor(serverResponse) {
+        this.id = serverResponse["id"];
+        this.model = new InferenceModel(serverResponse["model"]);
+        this.file = new InferenceFile(serverResponse["file"]);
+    }
+    toString() {
+        return ("Inference\n" +
+            "#########\n" +
+            this.model.toString() + "\n" +
+            this.file.toString() + "\n");
+    }
+}

package/src/v2/parsing/inference/field/baseField.d.ts

@@ -0,0 +1,9 @@
+import { FieldConfidence } from "./fieldConfidence.js";
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { FieldLocation } from "./fieldLocation.js";
+export declare abstract class BaseField {
+    protected _indentLevel: number;
+    confidence: FieldConfidence | undefined;
+    locations: Array<FieldLocation> | undefined;
+    protected constructor(rawResponse: StringDict, indentLevel?: number);
+}

package/src/v2/parsing/inference/field/baseField.js

@@ -0,0 +1,14 @@
+import { FieldLocation } from "./fieldLocation.js";
+export class BaseField {
+    constructor(rawResponse, indentLevel = 0) {
+        this._indentLevel = indentLevel;
+        if ("confidence" in rawResponse && rawResponse["confidence"] !== null) {
+            this.confidence = rawResponse["confidence"];
+        }
+        if ("locations" in rawResponse && rawResponse["locations"]) {
+            this.locations = rawResponse["locations"].map((location) => {
+                return location ? new FieldLocation(location) : "";
+            });
+        }
+    }
+}

package/src/v2/parsing/inference/field/fieldConfidence.js

@@ -0,0 +1,74 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+/**
+ * Confidence level of a field as returned by the V2 API.
+ */
+export var FieldConfidence;
+(function (FieldConfidence) {
+    FieldConfidence["Certain"] = "Certain";
+    FieldConfidence["High"] = "High";
+    FieldConfidence["Medium"] = "Medium";
+    FieldConfidence["Low"] = "Low";
+})(FieldConfidence || (FieldConfidence = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+(function (FieldConfidence) {
+    /**
+     * Converts a FieldConfidence value to an integer.
+     * @param confidence The FieldConfidence value to convert
+     * @returns Integer representation (Certain=4, High=3, Medium=2, Low=1)
+     */
+    function toInt(confidence) {
+        switch (confidence) {
+            case FieldConfidence.Certain:
+                return 4;
+            case FieldConfidence.High:
+                return 3;
+            case FieldConfidence.Medium:
+                return 2;
+            case FieldConfidence.Low:
+                return 1;
+            default:
+                throw new Error(`Unknown FieldConfidence value: ${confidence}`);
+        }
+    }
+    FieldConfidence.toInt = toInt;
+    /**
+     * Checks if the first FieldConfidence is greater than the second.
+     * @param a First FieldConfidence value
+     * @param b Second FieldConfidence value
+     * @returns true if a > b
+     */
+    function greaterThan(a, b) {
+        return toInt(a) > toInt(b);
+    }
+    FieldConfidence.greaterThan = greaterThan;
+    /**
+     * Checks if the first FieldConfidence is greater than or equal to the second.
+     * @param a First FieldConfidence value
+     * @param b Second FieldConfidence value
+     * @returns true if a >= b
+     */
+    function greaterThanOrEqual(a, b) {
+        return toInt(a) >= toInt(b);
+    }
+    FieldConfidence.greaterThanOrEqual = greaterThanOrEqual;
+    /**
+     * Checks if the first FieldConfidence is less than the second.
+     * @param a First FieldConfidence value
+     * @param b Second FieldConfidence value
+     * @returns true if a < b
+     */
+    function lessThan(a, b) {
+        return toInt(a) < toInt(b);
+    }
+    FieldConfidence.lessThan = lessThan;
+    /**
+     * Checks if the first FieldConfidence is less than or equal to the second.
+     * @param a First FieldConfidence value
+     * @param b Second FieldConfidence value
+     * @returns true if a <= b
+     */
+    function lessThanOrEqual(a, b) {
+        return toInt(a) <= toInt(b);
+    }
+    FieldConfidence.lessThanOrEqual = lessThanOrEqual;
+})(FieldConfidence || (FieldConfidence = {}));

package/src/v2/parsing/inference/field/fieldFactory.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Factory helper.
+ */
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { ListField } from "./listField.js";
+import { ObjectField } from "./objectField.js";
+import { SimpleField } from "./simpleField.js";
+export declare function createField(serverResponse: StringDict, indentLevel?: number): SimpleField | ObjectField | ListField;

package/src/v2/parsing/inference/field/fieldFactory.js

@@ -0,0 +1,19 @@
+import { MindeeDeserializationError } from "../../../../errors/index.js";
+import { ListField } from "./listField.js";
+import { ObjectField } from "./objectField.js";
+import { SimpleField } from "./simpleField.js";
+export function createField(serverResponse, indentLevel = 0) {
+    if (typeof serverResponse !== "object" || serverResponse === null) {
+        throw new MindeeDeserializationError(`Unrecognized field format ${JSON.stringify(serverResponse)}.`);
+    }
+    if ("items" in serverResponse) {
+        return new ListField(serverResponse, indentLevel);
+    }
+    if ("fields" in serverResponse) {
+        return new ObjectField(serverResponse, indentLevel);
+    }
+    if ("value" in serverResponse) {
+        return new SimpleField(serverResponse, indentLevel);
+    }
+    throw new MindeeDeserializationError(`Unrecognized field format in ${JSON.stringify(serverResponse)}.`);
+}

package/src/v2/parsing/inference/field/fieldLocation.d.ts

@@ -0,0 +1,13 @@
+import { Polygon } from "../../../../geometry/index.js";
+import { StringDict } from "../../../../parsing/stringDict.js";
+/**
+ * Location of a field.
+ */
+export declare class FieldLocation {
+    /** Free polygon made up of points (can be null when not provided). */
+    readonly polygon: Polygon | null;
+    /** Page ID. */
+    readonly page: number | undefined;
+    constructor(serverResponse: StringDict);
+    toString(): string;
+}

package/src/v2/parsing/inference/field/fieldLocation.js

@@ -0,0 +1,13 @@
+import { Polygon } from "../../../../geometry/index.js";
+/**
+ * Location of a field.
+ */
+export class FieldLocation {
+    constructor(serverResponse) {
+        this.polygon = "polygon" in serverResponse ? new Polygon(...serverResponse["polygon"]) : null;
+        this.page = "page" in serverResponse ? serverResponse["page"] : undefined;
+    }
+    toString() {
+        return this.polygon?.toString() ?? "";
+    }
+}

package/src/v2/parsing/inference/field/index.d.ts

@@ -0,0 +1,8 @@
+export { InferenceFields } from "./inferenceFields.js";
+export { FieldConfidence } from "./fieldConfidence.js";
+export { FieldLocation } from "./fieldLocation.js";
+export { ListField } from "./listField.js";
+export { ObjectField } from "./objectField.js";
+export { SimpleField } from "./simpleField.js";
+export { RawText } from "./rawText.js";
+export { RagMetadata } from "./ragMetadata.js";

package/src/v2/parsing/inference/field/index.js

@@ -0,0 +1,8 @@
+export { InferenceFields } from "./inferenceFields.js";
+export { FieldConfidence } from "./fieldConfidence.js";
+export { FieldLocation } from "./fieldLocation.js";
+export { ListField } from "./listField.js";
+export { ObjectField } from "./objectField.js";
+export { SimpleField } from "./simpleField.js";
+export { RawText } from "./rawText.js";
+export { RagMetadata } from "./ragMetadata.js";

package/src/v2/parsing/inference/field/inferenceFields.d.ts

@@ -0,0 +1,12 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+import type { ListField } from "./listField.js";
+import type { ObjectField } from "./objectField.js";
+import type { SimpleField } from "./simpleField.js";
+export declare class InferenceFields extends Map<string, SimpleField | ObjectField | ListField> {
+    protected _indentLevel: number;
+    constructor(serverResponse: StringDict, indentLevel?: number);
+    getSimpleField(fieldName: string): SimpleField;
+    getObjectField(fieldName: string): ObjectField;
+    getListField(fieldName: string): ListField;
+    toString(indent?: number): string;
+}

package/src/v2/parsing/inference/field/inferenceFields.js

@@ -0,0 +1,64 @@
+import { createField } from "./fieldFactory.js";
+export class InferenceFields extends Map {
+    constructor(serverResponse, indentLevel = 0) {
+        super(Object.entries(serverResponse).map(([key, value]) => {
+            return [key, createField(value, 1)];
+        }));
+        this._indentLevel = indentLevel;
+    }
+    getSimpleField(fieldName) {
+        const field = this.get(fieldName);
+        if (field === undefined) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (field.constructor.name !== "SimpleField") {
+            throw new Error(`The field '${fieldName}' is not a SimpleField.`);
+        }
+        return field;
+    }
+    getObjectField(fieldName) {
+        const field = this.get(fieldName);
+        if (field === undefined) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (field.constructor.name !== "ObjectField") {
+            throw new Error(`The field '${fieldName}' is not an ObjectField.`);
+        }
+        return field;
+    }
+    getListField(fieldName) {
+        const field = this.get(fieldName);
+        if (field === undefined) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (field.constructor.name !== "ListField") {
+            throw new Error(`The field '${fieldName}' is not a ListField.`);
+        }
+        return field;
+    }
+    toString(indent = this._indentLevel) {
+        if (this.size === 0) {
+            return "";
+        }
+        const padding = "  ".repeat(indent);
+        const lines = [];
+        for (const [fieldKey, fieldValue] of this.entries()) {
+            let line = `${padding}:${fieldKey}:`;
+            if (fieldValue.constructor.name === "ListField") {
+                const listField = fieldValue;
+                if (Array.isArray(listField.items) && listField.items.length > 0) {
+                    line += listField.toString();
+                }
+            }
+            else if (fieldValue.constructor.name === "ObjectField") {
+                line += fieldValue.toString();
+            }
+            else if (fieldValue.constructor.name === "SimpleField") {
+                const val = fieldValue.toString();
+                line += val.length > 0 ? " " + val.toString() : "";
+            }
+            lines.push(line);
+        }
+        return lines.join("\n").trimEnd();
+    }
+}

package/src/v2/parsing/inference/field/listField.d.ts

@@ -0,0 +1,20 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { BaseField } from "./baseField.js";
+import { ObjectField } from "./objectField.js";
+import { SimpleField } from "./simpleField.js";
+export declare class ListField extends BaseField {
+    /**
+     * Items contained in the list.
+     */
+    items: Array<ListField | ObjectField | SimpleField>;
+    /**
+     * SimpleField items from the list.
+     */
+    get simpleItems(): Array<SimpleField>;
+    /**
+     * SimpleField items from the list.
+     */
+    get objectItems(): Array<ObjectField>;
+    constructor(serverResponse: StringDict, indentLevel?: number);
+    toString(): string;
+}

package/src/v2/parsing/inference/field/listField.js

@@ -0,0 +1,63 @@
+import { MindeeDeserializationError } from "../../../../errors/index.js";
+import { BaseField } from "./baseField.js";
+import { ObjectField } from "./objectField.js";
+import { SimpleField } from "./simpleField.js";
+import { createField } from "./fieldFactory.js";
+export class ListField extends BaseField {
+    /**
+     * SimpleField items from the list.
+     */
+    get simpleItems() {
+        const result = [];
+        for (const item of this.items) {
+            if (item instanceof SimpleField) {
+                result.push(item);
+            }
+            else {
+                throw new MindeeDeserializationError(`All items must be SimpleField, found item of type ${item.constructor.name}.`);
+            }
+        }
+        return result;
+    }
+    /**
+     * SimpleField items from the list.
+     */
+    get objectItems() {
+        const result = [];
+        for (const item of this.items) {
+            if (item instanceof ObjectField) {
+                result.push(item);
+            }
+            else {
+                throw new MindeeDeserializationError(`All items must be ObjectField, found item of type ${item.constructor.name}.`);
+            }
+        }
+        return result;
+    }
+    constructor(serverResponse, indentLevel = 0) {
+        super(serverResponse, indentLevel);
+        if (!Array.isArray(serverResponse["items"])) {
+            throw new MindeeDeserializationError(`Expected "items" to be an array in ${JSON.stringify(serverResponse)}.`);
+        }
+        this.items = serverResponse["items"].map((item) => {
+            return createField(item, indentLevel + 1);
+        });
+    }
+    toString() {
+        if (!this.items || this.items.length === 0) {
+            return "\n";
+        }
+        const parts = [""];
+        for (const item of this.items) {
+            if (!item)
+                continue;
+            if (item instanceof ObjectField) {
+                parts.push(item.toStringFromList());
+            }
+            else {
+                parts.push(item.toString());
+            }
+        }
+        return parts.join("\n  * ");
+    }
+}

package/src/v2/parsing/inference/field/objectField.d.ts

@@ -0,0 +1,53 @@
+import { InferenceFields } from "./inferenceFields.js";
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { BaseField } from "./baseField.js";
+import type { SimpleField } from "./simpleField.js";
+import type { ListField } from "./listField.js";
+export declare class ObjectField extends BaseField {
+    readonly fields: InferenceFields;
+    /**
+     * Retrieves the simple sub-fields in the object.
+     *
+     * @return {Map<string, SimpleField>} A map of field names to their corresponding `SimpleField` instances.
+     */
+    get simpleFields(): Map<string, SimpleField>;
+    /**
+     * Retrieves the list sub-fields in the object.
+     *
+     * @return {Map<string, ListField>} A map of field names to their corresponding `ListField` instances.
+     */
+    get listFields(): Map<string, ListField>;
+    /**
+     * Retrieves the object sub-fields in the object.
+     *
+     * @return {Map<string, ObjectField>} A map of field names to their corresponding `ObjectField` instances.
+     */
+    get objectFields(): Map<string, ObjectField>;
+    /**
+     * Retrieves a SimpleField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {SimpleField} The SimpleField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type SimpleField.
+     */
+    getSimpleField(fieldName: string): SimpleField;
+    /**
+     * Retrieves a ListField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {ListField} The ListField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type ListField.
+     */
+    getListField(fieldName: string): ListField;
+    /**
+     * Retrieves an ObjectField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {ObjectField} The ObjectField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type ObjectField.
+     */
+    getObjectField(fieldName: string): ObjectField;
+    constructor(serverResponse: StringDict, indentLevel?: number);
+    toString(): string;
+    toStringFromList(): string;
+}

package/src/v2/parsing/inference/field/objectField.js

@@ -0,0 +1,104 @@
+import { InferenceFields } from "./inferenceFields.js";
+import { BaseField } from "./baseField.js";
+export class ObjectField extends BaseField {
+    /**
+     * Retrieves the simple sub-fields in the object.
+     *
+     * @return {Map<string, SimpleField>} A map of field names to their corresponding `SimpleField` instances.
+     */
+    get simpleFields() {
+        const result = new Map();
+        for (const [fieldName, fieldValue] of this.fields) {
+            if (fieldValue.constructor.name === "SimpleField") {
+                result.set(fieldName, fieldValue);
+            }
+        }
+        return result;
+    }
+    /**
+     * Retrieves the list sub-fields in the object.
+     *
+     * @return {Map<string, ListField>} A map of field names to their corresponding `ListField` instances.
+     */
+    get listFields() {
+        const result = new Map();
+        for (const [fieldName, fieldValue] of this.fields) {
+            if (fieldValue.constructor.name === "ListField") {
+                result.set(fieldName, fieldValue);
+            }
+        }
+        return result;
+    }
+    /**
+     * Retrieves the object sub-fields in the object.
+     *
+     * @return {Map<string, ObjectField>} A map of field names to their corresponding `ObjectField` instances.
+     */
+    get objectFields() {
+        const result = new Map();
+        for (const [fieldName, fieldValue] of this.fields) {
+            if (fieldValue.constructor.name === "ObjectField") {
+                result.set(fieldName, fieldValue);
+            }
+        }
+        return result;
+    }
+    /**
+     * Retrieves a SimpleField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {SimpleField} The SimpleField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type SimpleField.
+     */
+    getSimpleField(fieldName) {
+        if (!this.fields.has(fieldName) && !this.simpleFields.has(fieldName)) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (this.fields.get(fieldName)?.constructor.name !== "SimpleField") {
+            throw new Error(`The field '${fieldName}' is not a SimpleField.`);
+        }
+        return this.simpleFields.get(fieldName);
+    }
+    /**
+     * Retrieves a ListField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {ListField} The ListField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type ListField.
+     */
+    getListField(fieldName) {
+        if (!this.fields.has(fieldName) || !this.listFields.has(fieldName)) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (this.fields.get(fieldName)?.constructor.name !== "ListField") {
+            throw new Error(`The field '${fieldName}' is not a ListField.`);
+        }
+        return this.listFields.get(fieldName);
+    }
+    /**
+     * Retrieves an ObjectField by its name if it exists and is of the correct type.
+     *
+     * @param {string} fieldName - The name of the field to retrieve.
+     * @return {ObjectField} The ObjectField instance if it exists and is valid, or undefined if not.
+     * @throws {Error} If the field does not exist or is not of type ObjectField.
+     */
+    getObjectField(fieldName) {
+        if (!this.fields.has(fieldName) && !this.objectFields.has(fieldName)) {
+            throw new Error(`The field '${fieldName}' was not found.`);
+        }
+        if (this.fields.get(fieldName)?.constructor.name !== "ObjectField") {
+            throw new Error(`The field '${fieldName}' is not an ObjectField.`);
+        }
+        return this.objectFields.get(fieldName);
+    }
+    constructor(serverResponse, indentLevel = 0) {
+        super(serverResponse, indentLevel);
+        this.fields = new InferenceFields(serverResponse["fields"], this._indentLevel + 1);
+    }
+    toString() {
+        return "\n" + (this.fields ? this.fields.toString(1) : "");
+    }
+    toStringFromList() {
+        return this.fields ? this.fields.toString(2).substring(4) : "";
+    }
+}

package/src/v2/parsing/inference/field/ragMetadata.d.ts

@@ -0,0 +1,8 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+export declare class RagMetadata {
+    /**
+     * The UUID of the matched document used during the RAG operation.
+     */
+    retrievedDocumentId?: string;
+    constructor(serverResponse: StringDict);
+}

package/src/v2/parsing/inference/field/ragMetadata.js

@@ -0,0 +1,5 @@
+export class RagMetadata {
+    constructor(serverResponse) {
+        this.retrievedDocumentId = serverResponse["retrieved_document_id"] ?? undefined;
+    }
+}

package/src/v2/parsing/inference/field/rawText.d.ts

@@ -0,0 +1,10 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { RawTextPage } from "./rawTextPage.js";
+export declare class RawText {
+    /**
+     * List of pages with their extracted text content.
+     */
+    pages: Array<RawTextPage>;
+    constructor(serverResponse: StringDict);
+    toString(): string;
+}

package/src/v2/parsing/inference/field/rawText.js

@@ -0,0 +1,9 @@
+import { RawTextPage } from "./rawTextPage.js";
+export class RawText {
+    constructor(serverResponse) {
+        this.pages = serverResponse["pages"] ? serverResponse["pages"].map((rawTextPage) => new RawTextPage(rawTextPage)) : [];
+    }
+    toString() {
+        return this.pages.map(page => page.toString()).join("\n\n");
+    }
+}

package/src/v2/parsing/inference/field/rawTextPage.d.ts

@@ -0,0 +1,11 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+export declare class RawTextPage {
+    /**
+     * The text content found on the page.
+     */
+    content: string;
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse: StringDict);
+}

package/src/v2/parsing/inference/field/rawTextPage.js

@@ -0,0 +1,8 @@
+export class RawTextPage {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        this.content = serverResponse["content"];
+    }
+}

package/src/v2/parsing/inference/field/simpleField.d.ts

@@ -0,0 +1,19 @@
+import { StringDict } from "../../../../parsing/stringDict.js";
+import { BaseField } from "./baseField.js";
+export declare class SimpleField extends BaseField {
+    readonly value: string | number | boolean | null;
+    constructor(serverResponse: StringDict, indentLevel?: number);
+    /**
+     * Retrieves a string field value as a string.
+     */
+    get stringValue(): string | null;
+    /**
+     * Retrieves a number field value as a number.
+     */
+    get numberValue(): number | null;
+    /**
+     * Retrieves a boolean field value as a boolean.
+     */
+    get booleanValue(): boolean | null;
+    toString(): string;
+}