mindee 5.5.0 → 5.6.1

package/src/v1/cli.js

@@ -1,18 +1,26 @@
-import { Command, Option, } from "commander";
-import { Client, } from "./client.js";
-import { PageOptionsOperation, PathInput, } from "../input/index.js";
+import { PageOptionsOperation, PathInput } from "../input/index.js";
+import { Command, Option } from "commander";
 import * as console from "console";
-import { CLI_COMMAND_CONFIG, COMMAND_GENERATED, } from "./product/cliProducts.js";
+import { Client } from "./client.js";
+import { CLI_COMMAND_CONFIG, COMMAND_GENERATED } from "./product/cliProducts.js";
 const program = new Command();
 //
 // EXECUTE THE COMMANDS
 //
+/**
+ * Load the client with the given options.
+ * @param options Command options.
+ */
 function initClient(options) {
     return new Client({
         apiKey: options.apiKey,
         debug: options.debug,
     });
 }
+/**
+ * Load the product configuration for the given command.
+ * @param command Command name.
+ */
 function getConfig(command) {
     const conf = CLI_COMMAND_CONFIG.get(command);
     if (conf === undefined) {
@@ -20,6 +28,10 @@ function getConfig(command) {
     }
     return conf;
 }
+/**
+ * Load the page options for the given command.
+ * @param options Command options.
+ */
 function getPageOptions(options) {
     let pageOptions = undefined;
     if (options.cutPages) {
@@ -31,12 +43,23 @@ function getPageOptions(options) {
     }
     return pageOptions;
 }
+/**
+ * Load the prediction parameters for the given command.
+ * @param options Command options.
+ */
 function getPredictParams(options) {
     return {
         allWords: options.allWords,
         cropper: options.cropper,
     };
 }
+/**
+ * Call the parse endpoint for the given command.
+ * @param productClass Product class.
+ * @param command Command name.
+ * @param inputPath Input path.
+ * @param options Command options.
+ */
 async function callParse(productClass, command, inputPath, options) {
     const mindeeClient = initClient(options);
     const predictParams = getPredictParams(options);
@@ -61,6 +84,13 @@ async function callParse(productClass, command, inputPath, options) {
     }
     printResponse(response.document, options);
 }
+/**
+ * Call the enqueue and parse endpoint for the given command.
+ * @param productClass Product class.
+ * @param command Command name.
+ * @param inputPath Input path.
+ * @param options Command options.
+ */
 async function callEnqueueAndParse(productClass, command, inputPath, options) {
     const mindeeClient = initClient(options);
     const predictParams = getPredictParams(options);
@@ -84,11 +114,22 @@ async function callEnqueueAndParse(productClass, command, inputPath, options) {
     }
     printResponse(response.document, options);
 }
+/**
+ * Call the get document endpoint for the given command.
+ * @param productClass Product class.
+ * @param documentId Document ID.
+ * @param options Command options.
+ */
 async function callGetDocument(productClass, documentId, options) {
     const mindeeClient = initClient(options);
     const response = await mindeeClient.getDocument(productClass, documentId);
     printResponse(response.document, options);
 }
+/**
+ * Print the response for the given command.
+ * @param document Document.
+ * @param options Command options.
+ */
 function printResponse(document, options) {
     if (options.allWords) {
         document.ocr?.mVisionV1.pages.forEach((page) => {
@@ -107,9 +148,18 @@ function printResponse(document, options) {
 //
 // BUILD THE COMMANDS
 //
+/**
+ * Add the main options to the given command.
+ * @param prog Command.
+ */
 function addMainOptions(prog) {
     prog.option("-k, --api-key <api_key>", "API key for document endpoint");
 }
+/**
+ * Add the post options to the given command.
+ * @param prog Command.
+ * @param info Product configuration.
+ */
 function addPostOptions(prog, info) {
     prog.option("-c, --cut-pages", "keep only the first 5 pages of the document");
     if (info.allWords) {
@@ -117,14 +167,28 @@ function addPostOptions(prog, info) {
     }
     prog.argument("<input_path>", "full path to the file");
 }
+/**
+ * Add the custom post options to the given command.
+ * @param prog Command.
+ */
 function addCustomPostOptions(prog) {
     prog.requiredOption("-e, --endpoint <endpoint_name>", "API endpoint name (required)");
     prog.requiredOption("-a, --account <account_name>", "API account name for the endpoint (required)");
     prog.option("-v, --version <version>", "version for the endpoint, use the latest version if not specified");
 }
+/**
+ * Add the display options to the given command.
+ * @param prog Command.
+ */
 function addDisplayOptions(prog) {
     prog.option("-p, --pages", "show content of individual pages");
 }
+/**
+ * Route the command to the appropriate action.
+ * @param command Command.
+ * @param inputPath Input path.
+ * @param allOptions All options.
+ */
 function routeSwitchboard(command, inputPath, allOptions) {
     if (command.parent === null || command.parent === undefined) {
         throw new Error(`Improperly configured command: ${command.name()}`);
@@ -135,30 +199,24 @@ function routeSwitchboard(command, inputPath, allOptions) {
     }
     return callParse(docClass, command.name(), inputPath, allOptions);
 }
+/**
+ * Add the predict action to the given command.
+ * @param prog Command.
+ */
 function addPredictAction(prog) {
-    if (prog.name() === COMMAND_GENERATED) {
-        prog.action(function (inputPath, options, command) {
-            const allOptions = {
-                ...prog.parent?.parent?.opts(),
-                ...prog.parent?.opts(),
-                ...prog.opts(),
-                ...options,
-            };
-            return routeSwitchboard(command, inputPath, allOptions);
-        });
-    }
-    else {
-        prog.action(function (inputPath, options, command) {
-            const allOptions = {
-                ...prog.parent?.parent?.opts(),
-                ...prog.parent?.opts(),
-                ...prog.opts(),
-                ...options,
-            };
-            return routeSwitchboard(command, inputPath, allOptions);
-        });
-    }
+    prog.action(function (inputPath, options, command) {
+        const allOptions = {
+            ...prog.parent?.parent?.opts(),
+            ...prog.parent?.opts(),
+            ...prog.opts(),
+            ...options,
+        };
+        return routeSwitchboard(command, inputPath, allOptions);
+    });
 }
+/**
+ * Add the main CLI action.
+ */
 export function cli() {
     program.name("mindee")
         .description("Command line interface for Mindee products.")

package/src/v1/client.d.ts

@@ -60,34 +60,34 @@ export interface WorkflowOptions extends BaseOptions {
      */
     publicUrl?: string;
 }
+/** Timer options forwarded to `setTimeout` in polling loops. */
+export interface TimerOptions {
+    /** Whether the timer should keep the event loop active. */
+    ref?: boolean;
+    /** Optional signal used to abort timer waits. */
+    signal?: AbortSignal;
+}
 /**
  * Asynchronous polling parameters.
  */
 export interface OptionalAsyncOptions extends PredictOptions {
+    /** Delay in seconds before the first polling attempt. */
     initialDelaySec?: number;
+    /** Delay in seconds between polling attempts. */
     delaySec?: number;
+    /** Maximum number of polling attempts. */
     maxRetries?: number;
-    initialTimerOptions?: {
-        ref?: boolean;
-        signal?: AbortSignal;
-    };
-    recurringTimerOptions?: {
-        ref?: boolean;
-        signal?: AbortSignal;
-    };
+    /** Timer options used for the first delay. */
+    initialTimerOptions?: TimerOptions;
+    /** Timer options used for recurring polling delays. */
+    recurringTimerOptions?: TimerOptions;
 }
 export interface AsyncOptions extends PredictOptions {
     initialDelaySec: number;
     delaySec: number;
     maxRetries: number;
-    initialTimerOptions?: {
-        ref?: boolean;
-        signal?: AbortSignal;
-    };
-    recurringTimerOptions?: {
-        ref?: boolean;
-        signal?: AbortSignal;
-    };
+    initialTimerOptions?: TimerOptions;
+    recurringTimerOptions?: TimerOptions;
 }
 export interface ClientOptions {
     /** Your API key for all endpoints. */

package/src/v1/extraction/invoiceSplitterExtractor/extractedInvoiceSplitterImage.d.ts

@@ -3,7 +3,9 @@ import { ExtractedPdf } from "../../../pdf/index.js";
  * Wrapper class for extracted invoice pages.
  */
 export declare class ExtractedInvoiceSplitterImage extends ExtractedPdf {
+    /** Start page index of the extracted invoice segment. */
     readonly pageIdMin: number;
+    /** End page index of the extracted invoice segment. */
     readonly pageIdMax: number;
     constructor(bytes: Uint8Array, pageIndices: [number, number]);
 }

package/src/v1/extraction/invoiceSplitterExtractor/invoiceSplitterExtractor.js

@@ -3,6 +3,9 @@ import { InvoiceSplitterV1 } from "../../../v1/product/index.js";
 import { ExtractedInvoiceSplitterImage } from "../../../v1/extraction/index.js";
 import { loadOptionalDependency } from "../../../dependency/index.js";
 let pdfLib = null;
+/**
+ * Load the pdf-lib dependency.
+ */
 async function getPdfLib() {
     if (!pdfLib) {
         const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");
@@ -10,6 +13,12 @@ async function getPdfLib() {
     }
     return pdfLib;
 }
+/**
+ * Split the given PDF document into multiple PDF documents.
+ * @param pdfDoc PDF document.
+ * @param invoicePageGroups Page groups.
+ * @returns Extracted invoice splitter images.
+ */
 async function splitPdf(pdfDoc, invoicePageGroups) {
     const pdfLib = await getPdfLib();
     if (invoicePageGroups.length === 0) {
@@ -31,6 +40,11 @@ async function splitPdf(pdfDoc, invoicePageGroups) {
     }
     return generatedPdfs;
 }
+/**
+ * Load the PDF document from the given input file.
+ * @param inputFile Input file.
+ * @returns PDF document.
+ */
 async function getPdfDoc(inputFile) {
     const pdfLib = await getPdfLib();
     await inputFile.init();

package/src/v1/extraction/multiReceiptsExtractor/extractedMultiReceiptImage.d.ts

@@ -3,7 +3,9 @@ import { ExtractedImage } from "../../../image/index.js";
  * Wrapper class for extracted multiple-receipts images.
  */
 export declare class ExtractedMultiReceiptImage extends ExtractedImage {
+    /** Receipt index within the source page. */
     readonly receiptId: number;
+    /** Source page identifier. */
     readonly pageId: number;
     constructor(buffer: Uint8Array, pageId: number, receiptId: number);
 }

package/src/v1/extraction/multiReceiptsExtractor/multiReceiptsExtractor.js

@@ -4,6 +4,9 @@ import { ExtractedMultiReceiptImage } from "../../../v1/extraction/index.js";
 import { extractFromPage } from "../../../image/index.js";
 import { loadOptionalDependency } from "../../../dependency/index.js";
 let pdfLib = null;
+/**
+ * Load the pdf-lib dependency.
+ */
 async function getPdfLib() {
     if (!pdfLib) {
         const pdfLibImport = await loadOptionalDependency("@cantoo/pdf-lib", "Text Embedding");

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

@@ -1,8 +1,13 @@
 import { BaseSettings, MindeeApiConstructorProps } from "../../http/baseSettings.js";
+/** Default account owner for built-in v1 APIs. */
 export declare const STANDARD_API_OWNER: string;
+/** Runtime settings container for v1 API calls. */
 export declare class ApiSettingsV1 extends BaseSettings {
+    /** Default headers sent with each v1 API request. */
     baseHeaders: Record<string, string>;
     constructor({ apiKey, dispatcher, }: MindeeApiConstructorProps);
+    /** Resolves the API key from environment variables. */
     protected apiKeyFromEnv(): string;
+    /** Resolves the API hostname from environment variables. */
     protected hostnameFromEnv(): string;
 }

package/src/v1/http/apiSettingsV1.js

@@ -1,10 +1,12 @@
 import { logger } from "../../logger.js";
 import { BaseSettings } from "../../http/baseSettings.js";
 import { MindeeConfigurationError } from "../../errors/index.js";
+/** Default account owner for built-in v1 APIs. */
 export const STANDARD_API_OWNER = "mindee";
 const API_V1_KEY_ENVVAR_NAME = "MINDEE_API_KEY";
 const API_V1_HOST_ENVVAR_NAME = "MINDEE_API_HOST";
 const DEFAULT_MINDEE_API_HOST = "api.mindee.net";
+/** Runtime settings container for v1 API calls. */
 export class ApiSettingsV1 extends BaseSettings {
     constructor({ apiKey, dispatcher, }) {
         super(apiKey, dispatcher);
@@ -18,6 +20,7 @@ export class ApiSettingsV1 extends BaseSettings {
             Authorization: `Token ${this.apiKey}`,
         };
     }
+    /** Resolves the API key from environment variables. */
     apiKeyFromEnv() {
         const envVarValue = process.env[API_V1_KEY_ENVVAR_NAME];
         if (envVarValue) {
@@ -26,6 +29,7 @@ export class ApiSettingsV1 extends BaseSettings {
         }
         return "";
     }
+    /** Resolves the API hostname from environment variables. */
     hostnameFromEnv() {
         const envVarValue = process.env[API_V1_HOST_ENVVAR_NAME];
         if (envVarValue) {

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

@@ -1,6 +1,12 @@
 import { MindeeError } from "../../errors/index.js";
 import { StringDict } from "../../parsing/stringDict.js";
-import { BaseHttpResponse } from "../../http/apiCore.js";
+import { BaseHttpResponse } from "../../http/index.js";
+/**
+ * Handle the given error.
+ * @param urlName URL name.
+ * @param response Response.
+ * @param serverError Server error.
+ */
 export declare function handleError(urlName: string, response: BaseHttpResponse, serverError?: string): void;
 /**
  * `Error` wrapper for server (HTTP) errors.

package/src/v1/http/errors.js

@@ -1,109 +1,80 @@
 import { MindeeError } from "../../errors/index.js";
 import { errorHandler } from "../../errors/handler.js";
-export function handleError(urlName, response, serverError) {
-    let code;
+const HTML_ERROR_PATTERNS = [
+    ["Maximum pdf pages", { message: "TooManyPages", details: "Maximum amount of pdf pages reached." }],
+    ["Max file size is", { message: "FileTooLarge", details: "Maximum file size reached." }],
+    ["Invalid file type", { message: "InvalidFiletype", details: "Invalid file type." }],
+    ["Gateway timeout", { message: "RequestTimeout", details: "Request timed out." }],
+    ["Bad gateway", { message: "BadRequest", details: "Bad Gateway" }],
+    ["Too Many Requests", { message: "TooManyRequests", details: "Too Many Requests." }],
+];
+const ERROR_CLASSES_BY_CODE = new Map();
+/**
+ * Extract the status code from the given response.
+ * @param response Response.
+ * @returns Status code.
+ */
+function extractStatusCode(response) {
     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;
+            return 500;
         }
-        else if (response.data) {
-            code = response.data.api_request["status_code"];
+        if (response.data) {
+            return response.data.api_request["status_code"];
         }
     }
     catch {
-        code = 500;
+        return 500;
+    }
+    return undefined;
+}
+/**
+ * Extract the error object from an HTML error response body.
+ * @param reconstructed Reconstructed response body.
+ * @returns Error object.
+ */
+function errorObjFromHtml(reconstructed) {
+    for (const [needle, obj] of HTML_ERROR_PATTERNS) {
+        if (reconstructed.includes(needle)) {
+            return { ...obj };
+        }
     }
-    let errorObj;
+    return { message: "Unknown Server Error.", details: reconstructed };
+}
+/**
+ * Extract the error object from the given response.
+ * @param response Response.
+ * @returns Error object.
+ */
+function extractErrorObj(response) {
     try {
-        //Regular instances where the returned error is in JSON format.
-        errorObj = response.data.api_request.error;
+        // Regular instances where the returned error is in JSON format.
+        return response.data.api_request.error;
     }
     catch {
-        //Rare instances where errors are returned as HTML instead of JSON.
+        // 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,
-            };
-        }
+        return errorObjFromHtml(response.data.reconstructedResponse);
     }
+}
+/**
+ * Handle the given error.
+ * @param urlName URL name.
+ * @param response Response.
+ * @param serverError Server error.
+ */
+export function handleError(urlName, response, serverError) {
+    const code = extractStatusCode(response);
+    const errorObj = extractErrorObj(response);
     if (serverError !== undefined &&
-        (!("message" in errorObj) ||
-            !errorObj.message ||
-            errorObj.message.length === 0)) {
+        (!("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);
+    const errorClass = (code !== undefined && ERROR_CLASSES_BY_CODE.get(code)) || MindeeHttpErrorV1;
+    errorHandler.throw(new errorClass(errorObj, urlName, code));
 }
 /**
  * `Error` wrapper for server (HTTP) errors.
@@ -196,3 +167,11 @@ export class MindeeHttp504Error extends MindeeHttpErrorV1 {
         this.name = "MindeeHttp504Error";
     }
 }
+ERROR_CLASSES_BY_CODE.set(400, MindeeHttp400Error);
+ERROR_CLASSES_BY_CODE.set(401, MindeeHttp401Error);
+ERROR_CLASSES_BY_CODE.set(403, MindeeHttp403Error);
+ERROR_CLASSES_BY_CODE.set(404, MindeeHttp404Error);
+ERROR_CLASSES_BY_CODE.set(413, MindeeHttp413Error);
+ERROR_CLASSES_BY_CODE.set(429, MindeeHttp429Error);
+ERROR_CLASSES_BY_CODE.set(500, MindeeHttp500Error);
+ERROR_CLASSES_BY_CODE.set(504, MindeeHttp504Error);

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

@@ -1,19 +1,31 @@
 import { InputSource, PageOptions } from "../../input/index.js";
 import { ExecutionPriority } from "../../v1/parsing/common/index.js";
 interface HTTPParams {
+    /** Input source to submit to the API. */
     inputDoc: InputSource;
+    /** Enables full-text OCR output when supported. */
     fullText: boolean;
+    /** Optional local page filtering options applied before upload. */
     pageOptions?: PageOptions;
+    /** Enables Retrieval-Augmented Generation when supported. */
     rag?: boolean;
 }
+/** Parameters sent to synchronous/asynchronous prediction endpoints. */
 export interface PredictParams extends HTTPParams {
+    /** Enables word-level OCR details in the response. */
     includeWords: boolean;
+    /** Enables cropper extras in the response. */
     cropper: boolean;
+    /** Optional workflow ID used for workflow-backed inference. */
     workflowId?: string;
 }
+/** Parameters sent to workflow execution endpoints. */
 export interface WorkflowParams extends HTTPParams {
+    /** Custom alias assigned to the submitted file. */
     alias?: string;
+    /** Processing priority of the workflow execution. */
     priority?: ExecutionPriority;
+    /** Whether to request a public validation URL. */
     publicUrl?: string;
 }
 export {};

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

@@ -22,6 +22,10 @@ export declare class Job {
     milliSecsTaken?: number;
     constructor(jsonResponse: StringDict);
 }
+/**
+ * Parse a date string into UTC.
+ * @param date Date string.
+ */
 export declare function datetimeWithTimezone(date: string): Date;
 /** Wrapper for asynchronous jobs and parsing results.
  *

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

@@ -20,9 +20,12 @@ export class Job {
         }
     }
 }
-// Hideous thing to make sure dates sent back by the server are parsed correctly in UTC.
+/**
+ * Parse a date string into UTC.
+ * @param date Date string.
+ */
 export function datetimeWithTimezone(date) {
-    if (date.search(/\+[0-9]{2}:[0-9]{2}$/) === -1) {
+    if (date.search(/\+\d{2}:\d{2}$/) === -1) {
         date += "+00:00";
     }
     return new Date(date);

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

@@ -1,5 +1,9 @@
+/** Execution priority levels available for workflow requests. */
 export declare enum ExecutionPriority {
+    /** Low-priority background processing. */
     low = "low",
+    /** Standard processing priority. */
     medium = "medium",
+    /** High-priority processing. */
     high = "high"
 }

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

@@ -1,6 +1,10 @@
+/** Execution priority levels available for workflow requests. */
 export var ExecutionPriority;
 (function (ExecutionPriority) {
+    /** Low-priority background processing. */
     ExecutionPriority["low"] = "low";
+    /** Standard processing priority. */
     ExecutionPriority["medium"] = "medium";
+    /** High-priority processing. */
     ExecutionPriority["high"] = "high";
 })(ExecutionPriority || (ExecutionPriority = {}));

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

@@ -1,7 +1,9 @@
 import { PositionField } from "../../../../v1/parsing/standard/position.js";
 import { StringDict } from "../../../../parsing/stringDict.js";
 import { ExtraField } from "./extras.js";
+/** Cropper extra payload returned by compatible APIs. */
 export declare class CropperExtra extends ExtraField {
+    /** Cropped regions detected on the page. */
     cropping: PositionField[];
     constructor(rawPrediction: StringDict, pageId?: number);
     /**

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

@@ -1,9 +1,12 @@
 import { PositionField } from "../../../../v1/parsing/standard/position.js";
+// eslint-disable-next-line no-restricted-imports
 import { cleanOutString } from "../summaryHelper.js";
 import { ExtraField } from "./extras.js";
+/** Cropper extra payload returned by compatible APIs. */
 export class CropperExtra extends ExtraField {
     constructor(rawPrediction, pageId) {
         super();
+        /** Cropped regions detected on the page. */
         this.cropping = [];
         if (rawPrediction["cropping"] !== undefined) {
             rawPrediction["cropping"].forEach((crop) => {

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

@@ -1,9 +1,12 @@
+/** Base class for optional extras attached to predictions. */
 export declare abstract class ExtraField {
 }
 interface ExtraDict<T extends ExtraField> {
     [key: string]: T | (() => string);
 }
+/** Dictionary-like container for extra fields. */
 export declare class Extras<ExtraT extends ExtraField = ExtraField> implements ExtraDict<ExtraT> {
+    /** Dynamic map of extra values keyed by extra name. */
     [key: string]: ExtraT | (() => string);
     constructor(fields: Record<string, ExtraT>);
     /**