@retab/node 1.0.98 → 1.0.99

package/dist/api/edit/templates/client.js

@@ -1,136 +1,9 @@
 import { CompositionClient } from "../../../client.js";
-import { ZPaginatedList, ZInferFormSchemaRequest, ZInferFormSchemaResponse, ZMIMEData, ZEditResponse, } from "../../../types.js";
-import { ZEditTemplate, } from "../../../generated_types.js";
+import { ZEditResponse, ZInferFormSchemaRequest, ZInferFormSchemaResponse, } from "../../../types.js";
 export default class APIEditTemplates extends CompositionClient {
     constructor(client) {
         super(client);
     }
-    /**
-     * List edit templates with pagination and optional filtering.
-     *
-     * @param params - Pagination and filter parameters
-     * @param options - Optional request options
-     * @returns PaginatedList of EditTemplate objects
-     */
-    async list({ before, after, limit = 10, order = "desc", filename, mime_type, include_embeddings = false, sort_by = "created_at", } = {}, options) {
-        const params = {
-            before,
-            after,
-            limit,
-            order,
-            filename,
-            mime_type,
-            include_embeddings,
-            sort_by,
-        };
-        // Remove undefined values
-        const cleanParams = Object.fromEntries(Object.entries(params).filter(([_, v]) => v !== undefined));
-        return this._fetchJson(ZPaginatedList, {
-            url: "/edit/templates",
-            method: "GET",
-            params: { ...cleanParams, ...(options?.params || {}) },
-            headers: options?.headers,
-        });
-    }
-    /**
-     * Get an edit template by ID.
-     *
-     * @param template_id - The ID of the template to retrieve
-     * @param options - Optional request options
-     * @returns EditTemplate object
-     */
-    async get(template_id, options) {
-        return this._fetchJson(ZEditTemplate, {
-            url: `/edit/templates/${template_id}`,
-            method: "GET",
-            params: options?.params,
-            headers: options?.headers,
-        });
-    }
-    /**
-     * Create a new edit template.
-     *
-     * @param params - CreateEditTemplateRequest containing:
-     *   - name: Name of the template
-     *   - document: The document to use as a template (MIMEData, file path, Buffer, or Readable)
-     *   - form_fields: Array of form field definitions
-     * @param options - Optional request options
-     * @returns EditTemplate object
-     */
-    async create({ name, document, form_fields, }, options) {
-        const parsedDocument = await ZMIMEData.parseAsync(document);
-        return this._fetchJson(ZEditTemplate, {
-            url: "/edit/templates",
-            method: "POST",
-            body: {
-                name,
-                document: parsedDocument,
-                form_fields,
-                ...(options?.body || {}),
-            },
-            params: options?.params,
-            headers: options?.headers,
-        });
-    }
-    /**
-     * Update an existing edit template.
-     *
-     * @param template_id - The ID of the template to update
-     * @param params - UpdateEditTemplateRequest containing optional fields to update:
-     *   - name: New name for the template
-     *   - form_fields: Updated array of form field definitions
-     * @param options - Optional request options
-     * @returns EditTemplate object
-     */
-    async update(template_id, { name, form_fields, } = {}, options) {
-        const body = {};
-        if (name !== undefined)
-            body.name = name;
-        if (form_fields !== undefined)
-            body.form_fields = form_fields;
-        return this._fetchJson(ZEditTemplate, {
-            url: `/edit/templates/${template_id}`,
-            method: "PATCH",
-            body: { ...body, ...(options?.body || {}) },
-            params: options?.params,
-            headers: options?.headers,
-        });
-    }
-    /**
-     * Delete an edit template by ID.
-     *
-     * @param template_id - The ID of the template to delete
-     * @param options - Optional request options
-     */
-    async delete(template_id, options) {
-        return this._fetchJson({
-            url: `/edit/templates/${template_id}`,
-            method: "DELETE",
-            params: options?.params,
-            headers: options?.headers,
-        });
-    }
-    /**
-     * Duplicate an existing edit template.
-     *
-     * @param template_id - The ID of the template to duplicate
-     * @param params - DuplicateEditTemplateRequest containing optional:
-     *   - name: Name for the duplicated template (defaults to "{original_name} (copy)")
-     * @param options - Optional request options
-     * @returns EditTemplate object (the new duplicated template)
-     */
-    async duplicate(template_id, { name } = {}, options) {
-        const body = {};
-        if (name !== undefined)
-            body.name = name;
-        return this._fetchJson(ZEditTemplate, {
-            url: `/edit/templates/${template_id}/duplicate`,
-            method: "POST",
-            body: { ...body, ...(options?.body || {}) },
-            params: options?.params,
-            headers: options?.headers,
-        });
-    }
     /**
      * Generate (infer) form schema from a PDF document.
      *

package/dist/api/evals/classify/client.d.ts

@@ -0,0 +1,20 @@
+import { CompositionClient, RequestOptions } from "../../../client.js";
+import { MIMEDataInput } from "../../../types.js";
+export default class APIEvalsClassify extends CompositionClient {
+    process({ eval_id, iteration_id, document, model, metadata, ...rest }: {
+        eval_id: string;
+        iteration_id?: string;
+        document?: MIMEDataInput;
+        model?: string;
+        metadata?: Record<string, string>;
+    }, options?: RequestOptions): Promise<{
+        usage: {
+            credits: number;
+        };
+        result: {
+            reasoning: string;
+            classification: string;
+        };
+    }>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/api/evals/classify/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/api/evals/classify/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,aAAa,EAAqB,MAAM,mBAAmB,CAAC;AAGrE,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,iBAAiB;IACrD,OAAO,CAAC,EACV,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,QAAQ,EACR,GAAG,IAAI,EACV,EAAE;QACC,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KACrC,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;CAoB9B"}

package/dist/api/evals/classify/client.js

@@ -0,0 +1,25 @@
+import { CompositionClient } from "../../../client.js";
+import { ZClassifyResponse } from "../../../types.js";
+import { buildProcessMultipartBody } from "../helpers.js";
+export default class APIEvalsClassify extends CompositionClient {
+    async process({ eval_id, iteration_id, document, model, metadata, ...rest }, options) {
+        if ("documents" in rest) {
+            throw new Error("client.evals.classify.process(...) accepts only 'document'.");
+        }
+        const body = await buildProcessMultipartBody({
+            document,
+            model,
+            metadata,
+            extra: options?.body,
+        });
+        const url = iteration_id ? `/evals/classify/extract/${eval_id}/${iteration_id}` : `/evals/classify/extract/${eval_id}`;
+        return this._fetchJson(ZClassifyResponse, {
+            url,
+            method: "POST",
+            body,
+            bodyMime: "multipart/form-data",
+            params: options?.params,
+            headers: options?.headers,
+        });
+    }
+}

package/dist/api/evals/client.d.ts

@@ -0,0 +1,11 @@
+import { CompositionClient } from "../../client.js";
+import APIEvalsClassify from "./classify/client.js";
+import APIEvalsExtract from "./extract/client.js";
+import APIEvalsSplit from "./split/client.js";
+export default class APIEvals extends CompositionClient {
+    extract: APIEvalsExtract;
+    split: APIEvalsSplit;
+    classify: APIEvalsClassify;
+    constructor(client: CompositionClient);
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/api/evals/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/api/evals/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,gBAAgB,MAAM,sBAAsB,CAAC;AACpD,OAAO,eAAe,MAAM,qBAAqB,CAAC;AAClD,OAAO,aAAa,MAAM,mBAAmB,CAAC;AAE9C,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,iBAAiB;IAC5C,OAAO,EAAE,eAAe,CAAC;IACzB,KAAK,EAAE,aAAa,CAAC;IACrB,QAAQ,EAAE,gBAAgB,CAAC;gBAEtB,MAAM,EAAE,iBAAiB;CAMxC"}

package/dist/api/evals/client.js

@@ -0,0 +1,12 @@
+import { CompositionClient } from "../../client.js";
+import APIEvalsClassify from "./classify/client.js";
+import APIEvalsExtract from "./extract/client.js";
+import APIEvalsSplit from "./split/client.js";
+export default class APIEvals extends CompositionClient {
+    constructor(client) {
+        super(client);
+        this.extract = new APIEvalsExtract(this);
+        this.split = new APIEvalsSplit(this);
+        this.classify = new APIEvalsClassify(this);
+    }
+}

package/dist/api/evals/extract/client.d.ts

@@ -0,0 +1,287 @@
+import { CompositionClient, RequestOptions } from "../../../client.js";
+import { MIMEDataInput } from "../../../types.js";
+export default class APIEvalsExtract extends CompositionClient {
+    process({ eval_id, iteration_id, document, model, image_resolution_dpi, n_consensus, metadata, extraction_id, ...rest }: {
+        eval_id: string;
+        iteration_id?: string;
+        document?: MIMEDataInput;
+        model?: string;
+        image_resolution_dpi?: number;
+        n_consensus?: number;
+        metadata?: Record<string, string>;
+        extraction_id?: string;
+    }, options?: RequestOptions): Promise<{
+        object: "chat.completion";
+        id: string;
+        model: string;
+        choices: {
+            message: {
+                role: "assistant";
+                content?: string | null | undefined;
+                tool_calls?: {
+                    function: {
+                        arguments: string;
+                        name: string;
+                        parsed_arguments?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | null | undefined;
+                    };
+                    type: "function";
+                    id: string;
+                }[] | null | undefined;
+                function_call?: {
+                    arguments: string;
+                    name: string;
+                } | null | undefined;
+                refusal?: string | null | undefined;
+                annotations?: {
+                    type: "url_citation";
+                    url_citation: {
+                        url: string;
+                        title: string;
+                        end_index: number;
+                        start_index: number;
+                    };
+                }[] | null | undefined;
+                audio?: {
+                    id: string;
+                    data: string;
+                    expires_at: number;
+                    transcript: string;
+                } | null | undefined;
+                parsed?: any;
+            };
+            index: number;
+            logprobs?: {
+                content?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+                refusal?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+            } | null | undefined;
+            finish_reason?: "length" | "tool_calls" | "function_call" | "content_filter" | "stop" | null | undefined;
+            key_mapping?: Record<string, string | null | undefined> | null | undefined;
+        }[];
+        created: number;
+        likelihoods?: Record<string, any> | null | undefined;
+        extraction_id?: string | null | undefined;
+        usage?: {
+            credits: number;
+        } | {
+            completion_tokens: number;
+            prompt_tokens: number;
+            total_tokens: number;
+            completion_tokens_details?: {
+                accepted_prediction_tokens?: number | null | undefined;
+                audio_tokens?: number | null | undefined;
+                reasoning_tokens?: number | null | undefined;
+                rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+            prompt_tokens_details?: {
+                audio_tokens?: number | null | undefined;
+                cached_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        service_tier?: "default" | "auto" | "flex" | "scale" | "priority" | null | undefined;
+        system_fingerprint?: string | null | undefined;
+        request_at?: string | null | undefined;
+        first_token_at?: string | null | undefined;
+        last_token_at?: string | null | undefined;
+    }>;
+    processStream({ eval_id, iteration_id, document, model, image_resolution_dpi, n_consensus, metadata, extraction_id, ...rest }: {
+        eval_id: string;
+        iteration_id?: string;
+        document?: MIMEDataInput;
+        model?: string;
+        image_resolution_dpi?: number;
+        n_consensus?: number;
+        metadata?: Record<string, string>;
+        extraction_id?: string;
+    }, options?: RequestOptions): Promise<AsyncGenerator<{
+        object: "chat.completion.chunk";
+        id: string;
+        model: string;
+        choices: {
+            index: number;
+            delta: {
+                flat_likelihoods: Record<string, number>;
+                flat_parsed: Record<string, any>;
+                flat_deleted_keys: string[];
+                is_valid_json: boolean;
+                role?: "user" | "system" | "assistant" | "developer" | "tool" | null | undefined;
+                content?: string | null | undefined;
+                tool_calls?: {
+                    index: number;
+                    function?: {
+                        arguments?: string | null | undefined;
+                        name?: string | null | undefined;
+                    } | null | undefined;
+                    type?: "function" | null | undefined;
+                    id?: string | null | undefined;
+                }[] | null | undefined;
+                function_call?: {
+                    arguments?: string | null | undefined;
+                    name?: string | null | undefined;
+                } | null | undefined;
+                refusal?: string | null | undefined;
+                key_mapping?: Record<string, string | null | undefined> | null | undefined;
+                full_parsed?: Record<string, any> | null | undefined;
+            };
+            logprobs?: {
+                content?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+                refusal?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+            } | null | undefined;
+            finish_reason?: "length" | "tool_calls" | "function_call" | "content_filter" | "stop" | null | undefined;
+        }[];
+        created: number;
+        extraction_id?: string | null | undefined;
+        streaming_error?: {
+            code: string;
+            message: string;
+            details?: Record<string, any> | null | undefined;
+        } | null | undefined;
+        usage?: {
+            completion_tokens: number;
+            prompt_tokens: number;
+            total_tokens: number;
+            completion_tokens_details?: {
+                accepted_prediction_tokens?: number | null | undefined;
+                audio_tokens?: number | null | undefined;
+                reasoning_tokens?: number | null | undefined;
+                rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+            prompt_tokens_details?: {
+                audio_tokens?: number | null | undefined;
+                cached_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        service_tier?: "default" | "auto" | "flex" | "scale" | "priority" | null | undefined;
+        system_fingerprint?: string | null | undefined;
+        request_at?: string | null | undefined;
+        first_token_at?: string | null | undefined;
+        last_token_at?: string | null | undefined;
+    }, any, any>>;
+    process_stream(params: {
+        eval_id: string;
+        iteration_id?: string;
+        document?: MIMEDataInput;
+        model?: string;
+        image_resolution_dpi?: number;
+        n_consensus?: number;
+        metadata?: Record<string, string>;
+        extraction_id?: string;
+    }, options?: RequestOptions): Promise<AsyncGenerator<{
+        object: "chat.completion.chunk";
+        id: string;
+        model: string;
+        choices: {
+            index: number;
+            delta: {
+                flat_likelihoods: Record<string, number>;
+                flat_parsed: Record<string, any>;
+                flat_deleted_keys: string[];
+                is_valid_json: boolean;
+                role?: "user" | "system" | "assistant" | "developer" | "tool" | null | undefined;
+                content?: string | null | undefined;
+                tool_calls?: {
+                    index: number;
+                    function?: {
+                        arguments?: string | null | undefined;
+                        name?: string | null | undefined;
+                    } | null | undefined;
+                    type?: "function" | null | undefined;
+                    id?: string | null | undefined;
+                }[] | null | undefined;
+                function_call?: {
+                    arguments?: string | null | undefined;
+                    name?: string | null | undefined;
+                } | null | undefined;
+                refusal?: string | null | undefined;
+                key_mapping?: Record<string, string | null | undefined> | null | undefined;
+                full_parsed?: Record<string, any> | null | undefined;
+            };
+            logprobs?: {
+                content?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+                refusal?: {
+                    token: string;
+                    logprob: number;
+                    top_logprobs: {
+                        token: string;
+                        logprob: number;
+                        bytes?: number[] | null | undefined;
+                    }[];
+                    bytes?: number[] | null | undefined;
+                }[] | null | undefined;
+            } | null | undefined;
+            finish_reason?: "length" | "tool_calls" | "function_call" | "content_filter" | "stop" | null | undefined;
+        }[];
+        created: number;
+        extraction_id?: string | null | undefined;
+        streaming_error?: {
+            code: string;
+            message: string;
+            details?: Record<string, any> | null | undefined;
+        } | null | undefined;
+        usage?: {
+            completion_tokens: number;
+            prompt_tokens: number;
+            total_tokens: number;
+            completion_tokens_details?: {
+                accepted_prediction_tokens?: number | null | undefined;
+                audio_tokens?: number | null | undefined;
+                reasoning_tokens?: number | null | undefined;
+                rejected_prediction_tokens?: number | null | undefined;
+            } | null | undefined;
+            prompt_tokens_details?: {
+                audio_tokens?: number | null | undefined;
+                cached_tokens?: number | null | undefined;
+            } | null | undefined;
+        } | null | undefined;
+        service_tier?: "default" | "auto" | "flex" | "scale" | "priority" | null | undefined;
+        system_fingerprint?: string | null | undefined;
+        request_at?: string | null | undefined;
+        first_token_at?: string | null | undefined;
+        last_token_at?: string | null | undefined;
+    }, any, any>>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/api/evals/extract/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/api/evals/extract/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EACH,aAAa,EAGhB,MAAM,mBAAmB,CAAC;AAG3B,MAAM,CAAC,OAAO,OAAO,eAAgB,SAAQ,iBAAiB;IACpD,OAAO,CAAC,EACV,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,aAAa,EACb,GAAG,IAAI,EACV,EAAE;QACC,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,aAAa,CAAC,EAAE,MAAM,CAAC;KAC1B,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwBrB,aAAa,CAAC,EAChB,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,KAAK,EACL,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,aAAa,EACb,GAAG,IAAI,EACV,EAAE;QACC,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,aAAa,CAAC,EAAE,MAAM,CAAC;KAC1B,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA0BrB,cAAc,CAAC,MAAM,EAAE;QACzB,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,EAAE,aAAa,CAAC;QACzB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAClC,aAAa,CAAC,EAAE,MAAM,CAAC;KAC1B,EAAE,OAAO,CAAC,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAG9B"}

package/dist/api/evals/extract/client.js

@@ -0,0 +1,56 @@
+import { CompositionClient } from "../../../client.js";
+import { ZRetabParsedChatCompletion, ZRetabParsedChatCompletionChunk, } from "../../../types.js";
+import { buildProcessMultipartBody } from "../helpers.js";
+export default class APIEvalsExtract extends CompositionClient {
+    async process({ eval_id, iteration_id, document, model, image_resolution_dpi, n_consensus, metadata, extraction_id, ...rest }, options) {
+        if ("documents" in rest) {
+            throw new Error("client.evals.extract.process(...) accepts only 'document'.");
+        }
+        const body = await buildProcessMultipartBody({
+            document,
+            model,
+            image_resolution_dpi,
+            n_consensus,
+            metadata,
+            extraction_id,
+            extra: options?.body,
+        });
+        const url = iteration_id ? `/evals/extract/extract/${eval_id}/${iteration_id}` : `/evals/extract/extract/${eval_id}`;
+        return this._fetchJson(ZRetabParsedChatCompletion, {
+            url,
+            method: "POST",
+            body,
+            bodyMime: "multipart/form-data",
+            params: options?.params,
+            headers: options?.headers,
+        });
+    }
+    async processStream({ eval_id, iteration_id, document, model, image_resolution_dpi, n_consensus, metadata, extraction_id, ...rest }, options) {
+        if ("documents" in rest) {
+            throw new Error("client.evals.extract.processStream(...) accepts only 'document'.");
+        }
+        const body = await buildProcessMultipartBody({
+            document,
+            model,
+            image_resolution_dpi,
+            n_consensus,
+            metadata,
+            extraction_id,
+            extra: options?.body,
+        });
+        const url = iteration_id
+            ? `/evals/extract/extract/${eval_id}/${iteration_id}/stream`
+            : `/evals/extract/extract/${eval_id}/stream`;
+        return this._fetchStream(ZRetabParsedChatCompletionChunk, {
+            url,
+            method: "POST",
+            body,
+            bodyMime: "multipart/form-data",
+            params: options?.params,
+            headers: options?.headers,
+        });
+    }
+    async process_stream(params, options) {
+        return this.processStream(params, options);
+    }
+}

package/dist/api/evals/helpers.d.ts

@@ -0,0 +1,30 @@
+import * as z from "zod";
+import { MIMEDataInput } from "../../types.js";
+export declare function cleanObject<T extends Record<string, unknown>>(value: T): T;
+export declare function buildListParams({ before, after, limit, order, fields, extra, }?: {
+    before?: string;
+    after?: string;
+    limit?: number;
+    order?: "asc" | "desc";
+    fields?: string;
+    extra?: Record<string, unknown>;
+}): Record<string, unknown>;
+export declare function buildProcessMultipartBody({ document, documents, model, image_resolution_dpi, n_consensus, metadata, extraction_id, extra, }: {
+    document?: MIMEDataInput;
+    documents?: MIMEDataInput[];
+    model?: string;
+    image_resolution_dpi?: number;
+    n_consensus?: number;
+    metadata?: Record<string, string>;
+    extraction_id?: string;
+    extra?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+export declare function dataPaginatedArray<Schema extends z.ZodTypeAny>(schema: Schema): z.ZodEffects<z.ZodObject<{
+    data: z.ZodArray<Schema>;
+} & {
+    list_metadata: z.ZodTypeAny;
+}>, z.output<Schema>[], {
+    data: z.input<Schema>[];
+    list_metadata?: unknown;
+}>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/api/evals/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/api/evals/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAGzB,OAAO,EAAE,aAAa,EAAa,MAAM,gBAAgB,CAAC;AAE1D,wBAAgB,WAAW,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAI1E;AAED,wBAAgB,eAAe,CAAC,EAC5B,MAAM,EACN,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,KAAK,GACR,GAAE;IACC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC9B,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAS/B;AAED,wBAAsB,yBAAyB,CAAC,EAC5C,QAAQ,EACR,SAAS,EACT,KAAK,EACL,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,aAAa,EACb,KAAK,GACR,EAAE;IACC,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,SAAS,CAAC,EAAE,aAAa,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA0BnC;AAED,wBAAgB,kBAAkB,CAAC,MAAM,SAAS,CAAC,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU,CACzF,CAAC,CAAC,SAAS,CAAC;IACR,IAAI,EAAE,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC5B,GAAG;IACA,aAAa,EAAE,CAAC,CAAC,UAAU,CAAC;CAC/B,CAAC,EACF,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,EAClB;IACI,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B,CACJ,CAKA"}

package/dist/api/evals/helpers.js

@@ -0,0 +1,46 @@
+import * as z from "zod";
+import { mimeToBlob } from "../../mime.js";
+import { ZMIMEData } from "../../types.js";
+export function cleanObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([_, item]) => item !== undefined));
+}
+export function buildListParams({ before, after, limit, order, fields, extra, } = {}) {
+    return cleanObject({
+        before,
+        after,
+        limit,
+        order,
+        fields,
+        ...(extra || {}),
+    });
+}
+export async function buildProcessMultipartBody({ document, documents, model, image_resolution_dpi, n_consensus, metadata, extraction_id, extra, }) {
+    if (!document && !documents?.length) {
+        throw new Error("Either document or documents must be provided");
+    }
+    if (document && documents?.length) {
+        throw new Error("Provide either document or documents, not both");
+    }
+    const body = cleanObject({
+        model,
+        image_resolution_dpi,
+        n_consensus,
+        metadata: metadata ? JSON.stringify(metadata) : undefined,
+        extraction_id,
+        ...(extra || {}),
+    });
+    if (document) {
+        const parsedDocument = await ZMIMEData.parseAsync(document);
+        body.document = mimeToBlob(parsedDocument);
+        return body;
+    }
+    const parsedDocuments = await Promise.all((documents || []).map((item) => ZMIMEData.parseAsync(item)));
+    body.documents = parsedDocuments.map((item) => mimeToBlob(item));
+    return body;
+}
+export function dataPaginatedArray(schema) {
+    return z.object({
+        data: z.array(schema),
+        list_metadata: z.any().optional(),
+    }).transform((input) => input.data);
+}