@transloadit/zod 4.3.2 → 4.3.4

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,5 +1,5 @@
-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<{

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,5 +1,5 @@
-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<{

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,5 +1,5 @@
-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<{

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"}

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

@@ -1,5 +1,5 @@
-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 robotDocumentSplitInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"document-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-split.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,cAmClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWtC,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-split.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-split.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,cAmClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWtC,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-thumbs.d.ts

@@ -1,5 +1,5 @@
-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 robotDocumentThumbsInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-thumbs.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,cAuClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkKvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyB9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}
+{"version":3,"file":"document-thumbs.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/document-thumbs.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,cAuClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkKvC,CAAA;AAEX,eAAO,MAAM,qDAAqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAyB9D,CAAA;AAEJ,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qCAAqC,CAAC,CAAA;AACnG,MAAM,MAAM,+CAA+C,GAAG,CAAC,CAAC,KAAK,CACnE,OAAO,qDAAqD,CAC7D,CAAA;AAED,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/D,CAAA;AACD,MAAM,MAAM,6CAA6C,GACvD,kDAAkD,CAAA;AAEpD,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,KAAK,CACtE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,mEAAmE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE/E,CAAA;AACD,MAAM,MAAM,6DAA6D,GAAG,CAAC,CAAC,KAAK,CACjF,OAAO,mEAAmE,CAC3E,CAAA;AACD,MAAM,MAAM,kEAAkE,GAAG,CAAC,CAAC,KAAK,CACtF,OAAO,mEAAmE,CAC3E,CAAA"}

package/dist/v4/robots/dropbox-import.d.ts

@@ -1,5 +1,5 @@
-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 robotDropboxImportInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
@@ -23,6 +23,8 @@ export declare const robotDropboxImportInstructionsSchema: z.ZodObject<{
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/dropbox/import">;
+    access_token: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
     path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
 }, z.core.$strict>;
 export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.ZodObject<{
@@ -46,9 +48,10 @@ export declare const robotDropboxImportInstructionsWithHiddenFieldsSchema: z.Zod
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/dropbox/import">;
+    access_token: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
     path: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>;
     result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
-    access_token: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type RobotDropboxImportInstructions = z.infer<typeof robotDropboxImportInstructionsSchema>;
 export type RobotDropboxImportInstructionsWithHiddenFields = z.infer<typeof robotDropboxImportInstructionsWithHiddenFieldsSchema>;
@@ -74,6 +77,8 @@ export declare const interpolatableRobotDropboxImportInstructionsSchema: z.ZodOb
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/dropbox/import">;
+    access_token: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
     path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
 }, z.core.$strict>;
 export type InterpolatableRobotDropboxImportInstructions = InterpolatableRobotDropboxImportInstructionsInput;
@@ -99,9 +104,10 @@ export declare const interpolatableRobotDropboxImportInstructionsWithHiddenField
     }>>]>, z.ZodTransform<string[], boolean | ("import" | "meta" | "execute")[]>>]>>;
     credentials: z.ZodOptional<z.ZodString>;
     robot: z.ZodLiteral<"/dropbox/import">;
+    access_token: z.ZodOptional<z.ZodString>;
+    refresh_token: z.ZodOptional<z.ZodString>;
     path: z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>;
     result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
-    access_token: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type InterpolatableRobotDropboxImportInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotDropboxImportInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema>;

package/dist/v4/robots/dropbox-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-import.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,cAqClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;kBAetC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,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":"dropbox-import.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-import.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,cAqClB,CAAA;AAED,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;kBA2BtC,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/dropbox-import.js

@@ -42,6 +42,18 @@ export const robotDropboxImportInstructionsSchema = robotBase
     .merge(dropboxBase)
     .extend({
     robot: z.literal('/dropbox/import'),
+    access_token: z
+        .string()
+        .optional()
+        .describe(`
+The Dropbox OAuth access token. We recommend using <dfn>Template Credentials</dfn> via \`credentials\`, but you can use this parameter for dynamic Dropbox credentials.
+`),
+    refresh_token: z
+        .string()
+        .optional()
+        .describe(`
+The Dropbox OAuth refresh token. This is optional and can be used together with \`access_token\` for dynamic Dropbox credentials.
+`),
     path: path.describe(`
 The path in your Dropbox to the specific file or directory. If the path points to a file, only this file will be imported. For example: \`images/avatar.jpg\`.
 
@@ -57,7 +69,6 @@ export const robotDropboxImportInstructionsWithHiddenFieldsSchema = robotDropbox
     result: z
         .union([z.literal('debug'), robotDropboxImportInstructionsSchema.shape.result])
         .optional(),
-    access_token: z.string().optional(), // Legacy field for backward compatibility
 });
 export const interpolatableRobotDropboxImportInstructionsSchema = interpolateRobot(robotDropboxImportInstructionsSchema);
 export const interpolatableRobotDropboxImportInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDropboxImportInstructionsWithHiddenFieldsSchema);

package/dist/v4/robots/dropbox-store.d.ts

@@ -1,5 +1,5 @@
-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 robotDropboxStoreInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{

package/dist/v4/robots/dropbox-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropbox-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-store.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,cAoClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}
+{"version":3,"file":"dropbox-store.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/dropbox-store.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,cAoClB,CAAA;AAED,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkBrC,CAAA;AAEX,eAAO,MAAM,mDAAmD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM5D,CAAA;AAEJ,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AAC/F,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAA;AACpG,MAAM,MAAM,6CAA6C,GAAG,CAAC,CAAC,KAAK,CACjE,OAAO,mDAAmD,CAC3D,CAAA;AAED,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7D,CAAA;AACD,MAAM,MAAM,2CAA2C,GACrD,gDAAgD,CAAA;AAElD,MAAM,MAAM,gDAAgD,GAAG,CAAC,CAAC,KAAK,CACpE,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,iEAAiE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE7E,CAAA;AACD,MAAM,MAAM,2DAA2D,GAAG,CAAC,CAAC,KAAK,CAC/E,OAAO,iEAAiE,CACzE,CAAA;AACD,MAAM,MAAM,gEAAgE,GAAG,CAAC,CAAC,KAAK,CACpF,OAAO,iEAAiE,CACzE,CAAA"}

package/dist/v4/robots/edgly-deliver.d.ts

@@ -1,5 +1,5 @@
-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 robotEdglyDeliverInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{