@transloadit/zod 4.3.1 → 4.3.3

package/dist/v4/robots/document-extract.d.ts

@@ -0,0 +1,294 @@
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v4';
+export declare const meta: RobotMetaInput;
+export declare const robotDocumentExtractInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    result: z.ZodDefault<z.ZodBoolean>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    robot: z.ZodLiteral<"/document/extract">;
+    extract: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>, z.ZodArray<z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>>]>>;
+    page_range: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    text_method: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        native: "native";
+        ocr: "ocr";
+    }>>;
+    ocr_provider: z.ZodOptional<z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+    }>>;
+    text_format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        txt: "txt";
+    }>>;
+    text_granularity: z.ZodDefault<z.ZodEnum<{
+        document: "document";
+        page: "page";
+    }>>;
+    image_format: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        jpg: "jpg";
+        png: "png";
+        original: "original";
+    }>>;
+    min_image_width: z.ZodDefault<z.ZodNumber>;
+    min_image_height: z.ZodDefault<z.ZodNumber>;
+    min_image_bytes: z.ZodDefault<z.ZodNumber>;
+    dedupe_images: z.ZodDefault<z.ZodBoolean>;
+    include_image_masks: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const robotDocumentExtractInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    queue: z.ZodOptional<z.ZodEnum<{
+        batch: "batch";
+    }>>;
+    force_accept: z.ZodDefault<z.ZodBoolean>;
+    ignore_errors: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    robot: z.ZodLiteral<"/document/extract">;
+    extract: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>, z.ZodArray<z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>>]>>;
+    page_range: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    text_method: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        native: "native";
+        ocr: "ocr";
+    }>>;
+    ocr_provider: z.ZodOptional<z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+    }>>;
+    text_format: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        txt: "txt";
+    }>>;
+    text_granularity: z.ZodDefault<z.ZodEnum<{
+        document: "document";
+        page: "page";
+    }>>;
+    image_format: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        jpg: "jpg";
+        png: "png";
+        original: "original";
+    }>>;
+    min_image_width: z.ZodDefault<z.ZodNumber>;
+    min_image_height: z.ZodDefault<z.ZodNumber>;
+    min_image_bytes: z.ZodDefault<z.ZodNumber>;
+    dedupe_images: z.ZodDefault<z.ZodBoolean>;
+    include_image_masks: z.ZodDefault<z.ZodBoolean>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotDocumentExtractInstructions = z.infer<typeof robotDocumentExtractInstructionsSchema>;
+export type RobotDocumentExtractInstructionsWithHiddenFields = z.infer<typeof robotDocumentExtractInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotDocumentExtractInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "batch";
+    }>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    robot: z.ZodLiteral<"/document/extract">;
+    extract: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>]>>]>]>>;
+    page_range: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    text_method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        native: "native";
+        ocr: "ocr";
+    }>]>>;
+    ocr_provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+    }>]>>;
+    text_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        json: "json";
+        txt: "txt";
+    }>]>>;
+    text_granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        document: "document";
+        page: "page";
+    }>]>>;
+    image_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        jpg: "jpg";
+        png: "png";
+        original: "original";
+    }>]>>;
+    min_image_width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_height: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_bytes: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    dedupe_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    include_image_masks: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentExtractInstructions = InterpolatableRobotDocumentExtractInstructionsInput;
+export type InterpolatableRobotDocumentExtractInstructionsInput = z.input<typeof interpolatableRobotDocumentExtractInstructionsSchema>;
+export declare const interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+    output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+    queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        batch: "batch";
+    }>]>>;
+    force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodArray<z.ZodEnum<{
+        meta: "meta";
+        execute: "execute";
+    }>>]>, z.ZodTransform<string[], boolean | ("meta" | "execute")[]>>]>>;
+    use: z.ZodOptional<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fields: z.ZodOptional<z.ZodString>;
+        as: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>]>, z.ZodObject<{
+        steps: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>, z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fields: z.ZodOptional<z.ZodString>;
+            as: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>]>;
+        bundle_steps: z.ZodOptional<z.ZodBoolean>;
+        group_by_original: z.ZodOptional<z.ZodBoolean>;
+        fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>]>>;
+    robot: z.ZodLiteral<"/document/extract">;
+    extract: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        text: "text";
+        images: "images";
+    }>]>>]>]>>;
+    page_range: z.ZodOptional<z.ZodString>;
+    password: z.ZodOptional<z.ZodString>;
+    text_method: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        native: "native";
+        ocr: "ocr";
+    }>]>>;
+    ocr_provider: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+    }>]>>;
+    text_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        json: "json";
+        txt: "txt";
+    }>]>>;
+    text_granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        document: "document";
+        page: "page";
+    }>]>>;
+    image_format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        auto: "auto";
+        jpg: "jpg";
+        png: "png";
+        original: "original";
+    }>]>>;
+    min_image_width: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_height: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    min_image_bytes: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    dedupe_images: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    include_image_masks: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentExtractInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotDocumentExtractInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=document-extract.d.ts.map

package/dist/v4/robots/document-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-extract.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-extract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAW1B,eAAO,MAAM,IAAI,EAAE,cAoClB,CAAA;AAED,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkGxC,CAAA;AAEX,eAAO,MAAM,sDAAsD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK/D,CAAA;AAEJ,MAAM,MAAM,gCAAgC,GAAG,CAAC,CAAC,KAAK,CACpD,OAAO,sCAAsC,CAC9C,CAAA;AACD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,sDAAsD,CAC9D,CAAA;AAED,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEhE,CAAA;AACD,MAAM,MAAM,8CAA8C,GACxD,mDAAmD,CAAA;AAErD,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,KAAK,CACvE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC1E,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,oEAAoE,CAC5E,CAAA;AACD,MAAM,MAAM,mEAAmE,GAAG,CAAC,CAAC,KAAK,CACvF,OAAO,oEAAoE,CAC5E,CAAA"}

package/dist/v4/robots/document-extract.js

@@ -0,0 +1,151 @@
+import { z } from 'zod/v4';
+import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+const extractTargets = z.enum(['text', 'images']);
+const imageFormats = z.enum(['auto', 'original', 'png', 'jpg']);
+const ocrProviders = z.enum(['aws', 'gcp']);
+const textFormats = z.enum(['txt', 'json']);
+const textGranularities = z.enum(['document', 'page']);
+const textMethods = z.enum(['native', 'ocr', 'auto']);
+export const meta = {
+    bytescount: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code: {
+        steps: {
+            extracted: {
+                robot: '/document/extract',
+                use: ':original',
+                extract: ['text', 'images'],
+                text_method: 'native',
+            },
+        },
+    },
+    example_code_description: 'Extract native text and embedded raster images from a PDF document:',
+    minimum_charge: 1048576,
+    output_factor: 1,
+    override_lvl1: 'Document Processing',
+    purpose_sentence: 'extracts text and embedded images from PDF documents',
+    purpose_verb: 'extract',
+    purpose_word: 'extracts text and images',
+    purpose_words: 'Extracts text and embedded images',
+    service_slug: 'document-processing',
+    slot_count: 10,
+    title: 'Extract text and images from documents',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'document',
+    name: 'DocumentExtractRobot',
+    priceFactor: 1,
+    queueSlotCount: 10,
+    minimumCharge: 1048576,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'beta',
+};
+export const robotDocumentExtractInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/document/extract').describe(`
+Extracts native/selectable text and embedded raster image assets from PDF documents.
+
+This robot does not render full pages. If you need page images, use \`/document/thumbs\`. Vector graphics, charts, and page backgrounds are not always embedded raster images and may therefore not be returned by this robot.
+`),
+    extract: z
+        .union([extractTargets, z.array(extractTargets).min(1)])
+        .default(['text', 'images'])
+        .describe(`
+Selects which assets to extract. Use \`["text"]\`, \`["images"]\`, or \`["text", "images"]\`.
+`),
+    page_range: z
+        .string()
+        .regex(/^\s*\d+(?:\s*-\s*\d+)?(?:\s*,\s*\d+(?:\s*-\s*\d+)?)*\s*$/)
+        .optional()
+        .describe(`
+Optional comma-separated page selection, such as \`"1"\`, \`"1-3"\`, or \`"1,3-5"\`. Page numbers start at 1. Ranges are clamped to the detected page count.
+
+At most 1,000 selected pages are allowed per job.
+
+This is supported for native text extraction and embedded image extraction. OCR extraction currently works on the full document.
+`),
+    password: z
+        .string()
+        .optional()
+        .describe(`
+Password used to unlock encrypted PDFs for native text extraction and embedded image extraction. OCR extraction currently does not support encrypted PDFs, so do not combine this with \`text_method: "ocr"\` or \`text_method: "auto"\`.
+`),
+    text_method: textMethods.default('native').describe(`
+Controls how text is extracted.
+
+- \`"native"\` extracts selectable PDF text locally with Poppler. This is fast, but returns little or no text for scanned PDFs.
+- \`"ocr"\` delegates to \`/document/ocr\` and requires \`ocr_provider\`.
+- \`"auto"\` tries native extraction first, then falls back to OCR when no native text is found. This also requires \`ocr_provider\`.
+
+OCR modes currently cannot be combined with \`password\`.
+`),
+    ocr_provider: ocrProviders.optional().describe(`
+OCR provider to use when \`text_method\` is \`"ocr"\` or \`"auto"\`. Valid values are \`"aws"\` and \`"gcp"\`.
+`),
+    text_format: textFormats.default('txt').describe(`
+Output format for extracted text. Use \`"txt"\` for plain text or \`"json"\` for structured output.
+`),
+    text_granularity: textGranularities.default('document').describe(`
+Controls text output grouping for native extraction.
+
+- \`"document"\` creates one text result for the selected pages.
+- \`"page"\` creates one text result per selected page.
+
+Page granularity is currently only supported with \`text_method: "native"\`.
+`),
+    image_format: imageFormats.default('auto').describe(`
+Output format for extracted embedded raster images.
+
+- \`"auto"\` and \`"original"\` preserve the embedded image format where possible.
+- \`"png"\` asks Poppler to decode images as PNG.
+- \`"jpg"\` converts non-JPEG extracted images through \`/image/resize\`.
+`),
+    min_image_width: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe(`
+Minimum width in pixels for extracted images. Smaller images are ignored. Set to \`0\` to disable this filter.
+`),
+    min_image_height: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe(`
+Minimum height in pixels for extracted images. Smaller images are ignored. Set to \`0\` to disable this filter.
+`),
+    min_image_bytes: z
+        .number()
+        .int()
+        .min(0)
+        .default(0)
+        .describe(`
+Minimum file size in bytes for extracted images. Smaller images are ignored.
+`),
+    dedupe_images: z
+        .boolean()
+        .default(true)
+        .describe(`
+When enabled, identical extracted image files are emitted only once.
+`),
+    include_image_masks: z
+        .boolean()
+        .default(false)
+        .describe(`
+When enabled, the robot also keeps image mask files when Poppler exposes them as separate files.
+`),
+})
+    .strict();
+export const robotDocumentExtractInstructionsWithHiddenFieldsSchema = robotDocumentExtractInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotDocumentExtractInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotDocumentExtractInstructionsSchema = interpolateRobot(robotDocumentExtractInstructionsSchema);
+export const interpolatableRobotDocumentExtractInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentExtractInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/document-merge.d.ts

@@ -1,7 +1,14 @@
-import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -31,6 +38,13 @@ export declare const robotDocumentMergeInstructionsSchema: z.ZodObject<{
     output_password: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -62,6 +76,13 @@ export declare const robotDocumentMergeInstructionsWithHiddenFieldsSchema: z.Zod
 export type RobotDocumentMergeInstructions = z.infer<typeof robotDocumentMergeInstructionsSchema>;
 export type RobotDocumentMergeInstructionsWithHiddenFields = z.infer<typeof robotDocumentMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -93,6 +114,13 @@ export declare const interpolatableRobotDocumentMergeInstructionsSchema: z.ZodOb
 export type InterpolatableRobotDocumentMergeInstructions = InterpolatableRobotDocumentMergeInstructionsInput;
 export type InterpolatableRobotDocumentMergeInstructionsInput = z.input<typeof interpolatableRobotDocumentMergeInstructionsSchema>;
 export declare const interpolatableRobotDocumentMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";

package/dist/v4/robots/document-merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAoDlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"document-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAoDlB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqBtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}

package/dist/v4/robots/document-ocr.d.ts

@@ -1,7 +1,14 @@
-import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -45,6 +52,13 @@ export declare const robotDocumentOcrInstructionsSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export declare const robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -90,6 +104,13 @@ export declare const robotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodOb
 export type RobotDocumentOcrInstructions = z.infer<typeof robotDocumentOcrInstructionsSchema>;
 export type RobotDocumentOcrInstructionsWithHiddenFields = z.infer<typeof robotDocumentOcrInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -135,6 +156,13 @@ export declare const interpolatableRobotDocumentOcrInstructionsSchema: z.ZodObje
 export type InterpolatableRobotDocumentOcrInstructions = InterpolatableRobotDocumentOcrInstructionsInput;
 export type InterpolatableRobotDocumentOcrInstructionsInput = z.input<typeof interpolatableRobotDocumentOcrInstructionsSchema>;
 export declare const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";

package/dist/v4/robots/document-ocr.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AASnE,eAAO,MAAM,IAAI,EAAE,cA6ClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}
+{"version":3,"file":"document-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-ocr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cA6ClB,CAAA;AAED,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BpC,CAAA;AAEX,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK3D,CAAA;AAEJ,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kCAAkC,CAAC,CAAA;AAC7F,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5D,CAAA;AACD,MAAM,MAAM,0CAA0C,GACpD,+CAA+C,CAAA;AAEjD,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,gDAAgD,CACxD,CAAA;AAED,eAAO,MAAM,gEAAgE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE5E,CAAA;AACD,MAAM,MAAM,0DAA0D,GAAG,CAAC,CAAC,KAAK,CAC9E,OAAO,gEAAgE,CACxE,CAAA;AACD,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,gEAAgE,CACxE,CAAA"}

package/dist/v4/robots/document-optimize.d.ts

@@ -1,7 +1,14 @@
-import { z } from 'zod/v4';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
+import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotDocumentOptimizeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
@@ -47,6 +54,13 @@ export declare const robotDocumentOptimizeInstructionsSchema: z.ZodObject<{
     }>>;
 }, z.core.$strict>;
 export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -94,6 +108,13 @@ export declare const robotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.
 export type RobotDocumentOptimizeInstructions = z.infer<typeof robotDocumentOptimizeInstructionsSchema>;
 export type RobotDocumentOptimizeInstructionsWithHiddenFields = z.infer<typeof robotDocumentOptimizeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
@@ -141,6 +162,13 @@ export declare const interpolatableRobotDocumentOptimizeInstructionsSchema: z.Zo
 export type InterpolatableRobotDocumentOptimizeInstructions = InterpolatableRobotDocumentOptimizeInstructionsInput;
 export type InterpolatableRobotDocumentOptimizeInstructionsInput = z.input<typeof interpolatableRobotDocumentOptimizeInstructionsSchema>;
 export declare const interpolatableRobotDocumentOptimizeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
+        false: "false";
+        true: "true";
+    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodBoolean]>>, z.ZodUnion<[z.ZodString, z.ZodBoolean]>, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         batch: "batch";

package/dist/v4/robots/document-optimize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAGnE,eAAO,MAAM,IAAI,EAAE,cAwDlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}
+{"version":3,"file":"document-optimize.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-optimize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAI1B,eAAO,MAAM,IAAI,EAAE,cAwDlB,CAAA;AAED,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFzC,CAAA;AAEX,eAAO,MAAM,uDAAuD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKhE,CAAA;AAEJ,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,KAAK,CACrD,OAAO,uCAAuC,CAC/C,CAAA;AACD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,uDAAuD,CAC/D,CAAA;AAED,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEjE,CAAA;AACD,MAAM,MAAM,+CAA+C,GACzD,oDAAoD,CAAA;AAEtD,MAAM,MAAM,oDAAoD,GAAG,CAAC,CAAC,KAAK,CACxE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,qEAAqE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBACP,CAAA;AAC3E,MAAM,MAAM,+DAA+D,GAAG,CAAC,CAAC,KAAK,CACnF,OAAO,qEAAqE,CAC7E,CAAA;AACD,MAAM,MAAM,oEAAoE,GAAG,CAAC,CAAC,KAAK,CACxF,OAAO,qEAAqE,CAC7E,CAAA"}