mindee 4.36.3 → 5.0.0-alpha2

package/src/v2/client/pollingOptions.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Parameters for the internal polling loop in `enqueueAndGetInference()`.
+ *
+ * Default behavior:
+ * - `initialDelaySec` = 2s
+ * - `delaySec` = 1.5s
+ * - `maxRetries` = 80
+ *
+ * Validation rules:
+ * - `initialDelaySec` >= 1
+ * - `delaySec` >= 1
+ * - `maxRetries` >= 2
+ *
+ * The `initialTimerOptions` and `recurringTimerOptions` objects let you pass an
+ * `AbortSignal` or make the timer `unref`-ed to the `setTimeout()`.
+ *
+ * @category ClientV2
+ * @example
+ * const params = {
+ *   initialDelaySec: 4,
+ *   delaySec: 2,
+ *   maxRetries: 50
+ * };
+ *
+ * const inference = await client.enqueueAndGetInference(inputDoc, params);
+ */
+export interface PollingOptions {
+    /** Number of seconds to wait *before the first poll*. */
+    initialDelaySec?: number;
+    /** Interval in seconds between two consecutive polls. */
+    delaySec?: number;
+    /** Maximum number of polling attempts (including the first one). */
+    maxRetries?: number;
+    /** Options passed to the initial `setTimeout()`. */
+    initialTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+    /** Options passed to every recurring `setTimeout()`. */
+    recurringTimerOptions?: {
+        ref?: boolean;
+        signal?: AbortSignal;
+    };
+}
+export interface ValidatedPollingOptions extends PollingOptions {
+    initialDelaySec: number;
+    delaySec: number;
+    maxRetries: number;
+}

package/src/v2/client/pollingOptions.js

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

package/src/v2/client.d.ts

@@ -0,0 +1,79 @@
+import { Dispatcher } from "undici";
+import { InputSource } from "../input/index.js";
+import { JobResponse } from "./parsing/index.js";
+import { MindeeApiV2 } from "./http/mindeeApiV2.js";
+import { ValidatedPollingOptions } from "./client/index.js";
+import { BaseProduct } from "../v2/product/baseProduct.js";
+/**
+ * Options for the V2 Mindee Client.
+ *
+ * @category ClientV2
+ * @example
+ * const client = new MindeeClientV2({
+ *   apiKey: "YOUR_API_KEY",
+ *   throwOnError: true,
+ *   debug: false
+ * });
+ */
+export interface ClientOptions {
+    /** Your API key for all endpoints. */
+    apiKey?: string;
+    /** Log debug messages. */
+    debug?: boolean;
+    /** Custom Dispatcher instance for the HTTP requests. */
+    dispatcher?: Dispatcher;
+}
+/**
+ * Mindee Client V2 class that centralizes most basic operations.
+ *
+ * @category ClientV2
+ */
+export declare class Client {
+    /** Mindee V2 API handler. */
+    protected mindeeApi: MindeeApiV2;
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, debug, dispatcher }?: ClientOptions);
+    enqueue<P extends typeof BaseProduct>(product: P, inputSource: InputSource, params: InstanceType<P["parametersClass"]> | ConstructorParameters<P["parametersClass"]>[0]): Promise<JobResponse>;
+    /**
+     * Retrieves the result of a previously enqueued request.
+     *
+     * @param product the product to retrieve.
+     * @param inferenceId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing the inference.
+     */
+    getResult<P extends typeof BaseProduct>(product: P, inferenceId: string): Promise<InstanceType<P["responseClass"]>>;
+    /**
+     * Get the processing status of a previously enqueued request.
+     * Can be used for polling.
+     *
+     * @param jobId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    getJob(jobId: string): Promise<JobResponse>;
+    /**
+     * Enqueue a request and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param product the product to retrieve.
+     * @param inputSource file or URL to parse.
+     * @param params parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    enqueueAndGetResult<P extends typeof BaseProduct>(product: P, inputSource: InputSource, params: InstanceType<P["parametersClass"]> | ConstructorParameters<P["parametersClass"]>[0]): Promise<InstanceType<P["responseClass"]>>;
+    /**
+     * Send a document to an endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     * @protected
+     */
+    protected pollForResult<P extends typeof BaseProduct>(product: typeof BaseProduct, pollingOptions: ValidatedPollingOptions, queueId: string): Promise<InstanceType<P["responseClass"]>>;
+}

package/src/v2/client.js

@@ -0,0 +1,121 @@
+import { setTimeout } from "node:timers/promises";
+import { MindeeError } from "../errors/index.js";
+import { errorHandler } from "../errors/handler.js";
+import { LOG_LEVELS, logger } from "../logger.js";
+import { MindeeApiV2 } from "./http/mindeeApiV2.js";
+import { MindeeHttpErrorV2 } from "./http/errors.js";
+/**
+ * Mindee Client V2 class that centralizes most basic operations.
+ *
+ * @category ClientV2
+ */
+export class Client {
+    /**
+     * @param {ClientOptions} options options for the initialization of a client.
+     */
+    constructor({ apiKey, debug, dispatcher } = {
+        apiKey: undefined,
+        debug: false,
+        dispatcher: undefined,
+    }) {
+        this.mindeeApi = new MindeeApiV2(dispatcher, apiKey);
+        errorHandler.throwOnError = true;
+        logger.level =
+            debug ?? process.env.MINDEE_DEBUG
+                ? LOG_LEVELS["debug"]
+                : LOG_LEVELS["warn"];
+        logger.debug("Client V2 Initialized");
+    }
+    async enqueue(product, inputSource, params) {
+        if (inputSource === undefined) {
+            throw new MindeeError("An input document is required.");
+        }
+        const paramsInstance = params instanceof product.parametersClass
+            ? params
+            : new product.parametersClass(params);
+        await inputSource.init();
+        const jobResponse = await this.mindeeApi.enqueueProduct(product, inputSource, paramsInstance);
+        if (jobResponse.job.id === undefined || jobResponse.job.id.length === 0) {
+            logger.error(`Failed enqueueing:\n${jobResponse.getRawHttp()}`);
+            throw new MindeeError("Enqueueing of the document failed.");
+        }
+        logger.debug(`Successfully enqueued document with job ID: ${jobResponse.job.id}.`);
+        return jobResponse;
+    }
+    /**
+     * Retrieves the result of a previously enqueued request.
+     *
+     * @param product the product to retrieve.
+     * @param inferenceId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing the inference.
+     */
+    async getResult(product, inferenceId) {
+        logger.debug(`Attempting to get inference with ID: ${inferenceId} using response type: ${product.name}`);
+        return await this.mindeeApi.getProductResult(product, inferenceId);
+    }
+    /**
+     * Get the processing status of a previously enqueued request.
+     * Can be used for polling.
+     *
+     * @param jobId id of the queue to poll.
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Asynchronous
+     * @returns a `Promise` containing a `Job`, which also contains a `Document` if the
+     * parsing is complete.
+     */
+    async getJob(jobId) {
+        return await this.mindeeApi.getJob(jobId);
+    }
+    /**
+     * Enqueue a request and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     *
+     * @param product the product to retrieve.
+     * @param inputSource file or URL to parse.
+     * @param params parameters relating to prediction options.
+     *
+     * @typeParam T an extension of an `Inference`. Can be omitted as it will be inferred from the `productClass`.
+     * @category Synchronous
+     * @returns a `Promise` containing parsing results.
+     */
+    async enqueueAndGetResult(product, inputSource, params) {
+        const paramsInstance = new product.parametersClass(params);
+        const pollingOptions = paramsInstance.getValidatedPollingOptions();
+        const jobResponse = await this.enqueue(product, inputSource, paramsInstance);
+        return await this.pollForResult(product, pollingOptions, jobResponse.job.id);
+    }
+    /**
+     * Send a document to an endpoint and poll the server until the result is sent or
+     * until the maximum number of tries is reached.
+     * @protected
+     */
+    async pollForResult(product, pollingOptions, queueId) {
+        logger.debug(`Waiting ${pollingOptions.initialDelaySec} seconds before polling.`);
+        await setTimeout(pollingOptions.initialDelaySec * 1000, undefined, pollingOptions.initialTimerOptions);
+        logger.debug(`Start polling for inference using job ID: ${queueId}.`);
+        let retryCounter = 1;
+        let pollResults;
+        while (retryCounter < pollingOptions.maxRetries + 1) {
+            logger.debug(`Attempt ${retryCounter} of ${pollingOptions.maxRetries}`);
+            pollResults = await this.getJob(queueId);
+            const error = pollResults.job.error;
+            if (error) {
+                throw new MindeeHttpErrorV2(error);
+            }
+            logger.debug(`Job status: ${pollResults.job.status}.`);
+            if (pollResults.job.status === "Failed") {
+                break;
+            }
+            if (pollResults.job.status === "Processed") {
+                return this.getResult(product, pollResults.job.id);
+            }
+            await setTimeout(pollingOptions.delaySec * 1000, undefined, pollingOptions.recurringTimerOptions);
+            retryCounter++;
+        }
+        throw new MindeeError("Asynchronous parsing request timed out after " +
+            pollingOptions.delaySec * retryCounter +
+            " seconds");
+    }
+}

package/src/v2/http/apiSettingsV2.d.ts

@@ -0,0 +1,7 @@
+import { BaseSettings, MindeeApiConstructorProps } from "../../http/baseSettings.js";
+export declare class ApiSettingsV2 extends BaseSettings {
+    baseHeaders: Record<string, string>;
+    constructor({ apiKey, dispatcher, }: MindeeApiConstructorProps);
+    protected apiKeyFromEnv(): string;
+    protected hostnameFromEnv(): string;
+}

package/src/v2/http/apiSettingsV2.js

@@ -0,0 +1,36 @@
+import { logger } from "../../logger.js";
+import { BaseSettings } from "../../http/baseSettings.js";
+import { MindeeConfigurationError } from "../../errors/index.js";
+const API_V2_KEY_ENVVAR_NAME = "MINDEE_V2_API_KEY";
+const API_V2_HOST_ENVVAR_NAME = "MINDEE_V2_API_HOST";
+const DEFAULT_MINDEE_API_HOST = "api-v2.mindee.net";
+export class ApiSettingsV2 extends BaseSettings {
+    constructor({ apiKey, dispatcher, }) {
+        super(apiKey, dispatcher);
+        if (!this.apiKey || this.apiKey.length === 0) {
+            throw new MindeeConfigurationError("Your V2 API key could not be set, check your Client Configuration\n."
+                + `You can set this using the ${API_V2_KEY_ENVVAR_NAME} environment variable.`);
+        }
+        /* eslint-disable @typescript-eslint/naming-convention */
+        this.baseHeaders = {
+            "User-Agent": this.getUserAgent(),
+            Authorization: `${this.apiKey}`,
+        };
+    }
+    apiKeyFromEnv() {
+        const envVarValue = process.env[API_V2_KEY_ENVVAR_NAME];
+        if (envVarValue) {
+            logger.debug("Set the V2 API key from the environment");
+            return envVarValue;
+        }
+        return "";
+    }
+    hostnameFromEnv() {
+        const envVarValue = process.env[API_V2_HOST_ENVVAR_NAME];
+        if (envVarValue) {
+            logger.debug(`Set the V2 API hostname from the environment to: ${envVarValue}`);
+            return envVarValue;
+        }
+        return DEFAULT_MINDEE_API_HOST;
+    }
+}

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

@@ -0,0 +1,10 @@
+import { ErrorDetails, ErrorItem, ErrorResponse } from "../../v2/parsing/index.js";
+import { MindeeError } from "../../errors/index.js";
+export declare class MindeeHttpErrorV2 extends MindeeError implements ErrorDetails {
+    status: number;
+    detail: string;
+    title: string;
+    code: string;
+    errors: ErrorItem[];
+    constructor(error: ErrorResponse);
+}

package/src/v2/http/errors.js

@@ -0,0 +1,12 @@
+import { MindeeError } from "../../errors/index.js";
+export class MindeeHttpErrorV2 extends MindeeError {
+    constructor(error) {
+        super(`HTTP ${error.status} - ${error.title} :: ${error.code} - ${error.detail}`);
+        this.status = error.status;
+        this.detail = error.detail;
+        this.title = error.title;
+        this.code = error.code;
+        this.errors = error.errors;
+        this.name = "MindeeHttpErrorV2";
+    }
+}

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

@@ -0,0 +1 @@
+export { MindeeHttpErrorV2 } from "./errors.js";

package/src/v2/http/index.js

@@ -0,0 +1 @@
+export { MindeeHttpErrorV2 } from "./errors.js";

package/src/v2/http/mindeeApiV2.d.ts

@@ -0,0 +1,38 @@
+import { ApiSettingsV2 } from "./apiSettingsV2.js";
+import { Dispatcher } from "undici";
+import { BaseParameters } from "../../v2/client/index.js";
+import { JobResponse } from "../../v2/parsing/index.js";
+import { InputSource } from "../../input/index.js";
+import { BaseProduct } from "../../v2/product/baseProduct.js";
+export declare class MindeeApiV2 {
+    #private;
+    settings: ApiSettingsV2;
+    constructor(dispatcher?: Dispatcher, apiKey?: string);
+    /**
+     * Sends a file to the extraction inference queue.
+     * @param product product to enqueue.
+     * @param inputSource Local file loaded as an input.
+     * @param params {ExtractionParameters} parameters relating to the enqueueing options.
+     * @category V2
+     * @throws Error if the server's response contains one.
+     * @returns a `Promise` containing a job response.
+     */
+    enqueueProduct(product: typeof BaseProduct, inputSource: InputSource, params: BaseParameters): Promise<JobResponse>;
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param jobId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing information on the queue.
+     */
+    getJob(jobId: string): Promise<JobResponse>;
+    /**
+     * Requests the job of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param product
+     * @param inferenceId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    getProductResult<P extends typeof BaseProduct>(product: P, inferenceId: string): Promise<InstanceType<P["responseClass"]>>;
+}

package/src/v2/http/mindeeApiV2.js

@@ -0,0 +1,131 @@
+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 _MindeeApiV2_instances, _MindeeApiV2_processResponse, _MindeeApiV2_reqPostProductEnqueue, _MindeeApiV2_reqGetJob, _MindeeApiV2_reqGetProductResult;
+import { ApiSettingsV2 } from "./apiSettingsV2.js";
+import { ErrorResponse, JobResponse, } from "../../v2/parsing/index.js";
+import { sendRequestAndReadResponse } from "../../http/apiCore.js";
+import { LocalInputSource } from "../../input/index.js";
+import { MindeeDeserializationError } from "../../errors/index.js";
+import { MindeeHttpErrorV2 } from "./errors.js";
+import { logger } from "../../logger.js";
+export class MindeeApiV2 {
+    constructor(dispatcher, apiKey) {
+        _MindeeApiV2_instances.add(this);
+        this.settings = new ApiSettingsV2({ dispatcher: dispatcher, apiKey: apiKey });
+    }
+    /**
+     * Sends a file to the extraction inference queue.
+     * @param product product to enqueue.
+     * @param inputSource Local file loaded as an input.
+     * @param params {ExtractionParameters} parameters relating to the enqueueing options.
+     * @category V2
+     * @throws Error if the server's response contains one.
+     * @returns a `Promise` containing a job response.
+     */
+    async enqueueProduct(product, inputSource, params) {
+        await inputSource.init();
+        const result = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_reqPostProductEnqueue).call(this, product, inputSource, params);
+        if (result.data.error !== undefined) {
+            throw new MindeeHttpErrorV2(result.data.error);
+        }
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, result, JobResponse);
+    }
+    /**
+     * Requests the results of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param jobId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing information on the queue.
+     */
+    async getJob(jobId) {
+        const response = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_reqGetJob).call(this, jobId);
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, response, JobResponse);
+    }
+    /**
+     * Requests the job of a queued document from the API.
+     * Throws an error if the server's response contains one.
+     * @param product
+     * @param inferenceId The document's ID in the queue.
+     * @category Asynchronous
+     * @returns a `Promise` containing either the parsed result, or information on the queue.
+     */
+    async getProductResult(product, inferenceId) {
+        const queueResponse = await __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_reqGetProductResult).call(this, inferenceId, product.slug);
+        return __classPrivateFieldGet(this, _MindeeApiV2_instances, "m", _MindeeApiV2_processResponse).call(this, queueResponse, product.responseClass);
+    }
+}
+_MindeeApiV2_instances = new WeakSet(), _MindeeApiV2_processResponse = function _MindeeApiV2_processResponse(result, responseClass) {
+    if (result.messageObj?.statusCode && (result.messageObj?.statusCode > 399 || result.messageObj?.statusCode < 200)) {
+        if (result.data?.status !== null) {
+            throw new MindeeHttpErrorV2(new ErrorResponse(result.data));
+        }
+        throw new MindeeHttpErrorV2(new ErrorResponse({
+            status: result.messageObj?.statusCode ?? -1,
+            title: "Unknown Error",
+            detail: result.data?.detail ?? "The server returned an Unknown error.",
+            code: `${result.messageObj?.statusCode ?? -1}-000`,
+        }));
+    }
+    try {
+        return new responseClass(result.data);
+    }
+    catch (e) {
+        logger.error(`Raised '${e}' Couldn't deserialize response object:\n${JSON.stringify(result.data)}`);
+        throw new MindeeDeserializationError("Couldn't deserialize response object.");
+    }
+}, _MindeeApiV2_reqPostProductEnqueue = 
+/**
+ * Sends a document to the inference queue.
+ *
+ * @param product Product to enqueue.
+ * @param inputSource Local or remote file as an input.
+ * @param params {ExtractionParameters} parameters relating to the enqueueing options.
+ */
+async function _MindeeApiV2_reqPostProductEnqueue(product, inputSource, params) {
+    const form = params.getFormData();
+    if (inputSource instanceof LocalInputSource) {
+        form.set("file", new Blob([inputSource.fileObject]), inputSource.filename);
+    }
+    else {
+        form.set("url", inputSource.url);
+    }
+    const path = `/v2/products/${product.slug}/enqueue`;
+    const options = {
+        method: "POST",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: path,
+        body: form,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _MindeeApiV2_reqGetJob = async function _MindeeApiV2_reqGetJob(jobId) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `/v2/jobs/${jobId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+}, _MindeeApiV2_reqGetProductResult = 
+/**
+ * Make a request to GET the status of a document in the queue.
+ * @param inferenceId ID of the inference.
+ * @param slug "jobs" or "inferences"...
+ * @category Asynchronous
+ * @returns a `Promise` containing either the parsed result, or information on the queue.
+ */
+async function _MindeeApiV2_reqGetProductResult(inferenceId, slug) {
+    const options = {
+        method: "GET",
+        headers: this.settings.baseHeaders,
+        hostname: this.settings.hostname,
+        path: `/v2/products/${slug}/results/${inferenceId}`,
+        timeout: this.settings.timeout,
+    };
+    return await sendRequestAndReadResponse(this.settings.dispatcher, options);
+};

package/src/v2/index.d.ts

@@ -0,0 +1,6 @@
+export * as http from "./http/index.js";
+export * as parsing from "./parsing/index.js";
+export * as product from "./product/index.js";
+export { Client } from "./client.js";
+export { JobResponse, ErrorResponse, LocalResponse, } from "./parsing/index.js";
+export type { PollingOptions, BaseParameters } from "./client/index.js";

package/src/v2/index.js

@@ -0,0 +1,5 @@
+export * as http from "./http/index.js";
+export * as parsing from "./parsing/index.js";
+export * as product from "./product/index.js";
+export { Client } from "./client.js";
+export { JobResponse, ErrorResponse, LocalResponse, } from "./parsing/index.js";

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

@@ -0,0 +1,17 @@
+import { StringDict } from "../../parsing/stringDict.js";
+export declare abstract class BaseResponse {
+    /**
+     * Raw text representation of the API's response.
+     */
+    private readonly rawHttp;
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    protected constructor(serverResponse: StringDict);
+    /**
+     * Raw HTTP request sent from server, as a JSON-like structure
+     * @returns The HTTP request
+     */
+    getRawHttp(): StringDict;
+}
+export type ResponseConstructor<T extends BaseResponse> = new (serverResponse: StringDict) => T;

package/src/v2/parsing/baseResponse.js

@@ -0,0 +1,17 @@
+import { logger } from "../../logger.js";
+export class BaseResponse {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        this.rawHttp = serverResponse;
+        logger.debug("Constructing response instance from plain object.");
+    }
+    /**
+     * Raw HTTP request sent from server, as a JSON-like structure
+     * @returns The HTTP request
+     */
+    getRawHttp() {
+        return this.rawHttp;
+    }
+}

package/src/v2/parsing/error/errorDetails.d.ts

@@ -0,0 +1,23 @@
+import { ErrorItem } from "./errorItem.js";
+export interface ErrorDetails {
+    /**
+     * The HTTP status code returned by the server.
+     */
+    status: number;
+    /**
+     * A human-readable explanation specific to the occurrence of the problem.
+     */
+    detail: string;
+    /**
+     * A short, human-readable summary of the problem.
+     */
+    title: string;
+    /**
+     * A machine-readable code specific to the occurrence of the problem.
+     */
+    code: string;
+    /**
+     * A list of explicit error details.
+     */
+    errors: ErrorItem[];
+}

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

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

package/src/v2/parsing/error/errorItem.d.ts

@@ -0,0 +1,18 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+/**
+ * Explicit details on a problem.
+ */
+export declare class ErrorItem {
+    /**
+     * A JSON Pointer to the location of the body property.
+     */
+    pointer?: string;
+    /**
+     * Explicit information on the issue.
+     */
+    detail: string;
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse: StringDict);
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Explicit details on a problem.
+ */
+export class ErrorItem {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        if (serverResponse["pointer"] !== undefined) {
+            this.pointer = serverResponse["pointer"];
+        }
+        this.detail = serverResponse["detail"];
+    }
+}

package/src/v2/parsing/error/errorResponse.d.ts

@@ -0,0 +1,18 @@
+import { StringDict } from "../../../parsing/stringDict.js";
+import { ErrorItem } from "./errorItem.js";
+import { ErrorDetails } from "./errorDetails.js";
+import { BaseResponse } from "../../../v2/parsing/baseResponse.js";
+/**
+ * Error response detailing a problem. The format adheres to RFC 9457.
+ */
+export declare class ErrorResponse extends BaseResponse implements ErrorDetails {
+    status: number;
+    detail: string;
+    title: string;
+    code: string;
+    errors: ErrorItem[];
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse: StringDict);
+}

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

@@ -0,0 +1,23 @@
+import { ErrorItem } from "./errorItem.js";
+import { BaseResponse } from "../../../v2/parsing/baseResponse.js";
+/**
+ * Error response detailing a problem. The format adheres to RFC 9457.
+ */
+export class ErrorResponse extends BaseResponse {
+    /**
+     * @param serverResponse JSON response from the server.
+     */
+    constructor(serverResponse) {
+        super(serverResponse);
+        this.status = serverResponse["status"];
+        this.detail = serverResponse["detail"];
+        this.title = serverResponse["title"];
+        this.code = serverResponse["code"];
+        if (serverResponse["errors"] !== undefined) {
+            this.errors = serverResponse["errors"].map((error) => new ErrorItem(error));
+        }
+        else {
+            this.errors = [];
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+export { ErrorResponse } from "./errorResponse.js";
+export { ErrorItem } from "./errorItem.js";
+export type { ErrorDetails } from "./errorDetails.js";