@transloadit/zod 4.1.5 → 4.1.6

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

@@ -0,0 +1,85 @@
+import { z } from 'zod/v4';
+import { aiProviderSchema, granularitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code: {
+        steps: {
+            recognized: {
+                robot: '/document/ocr',
+                use: ':original',
+                provider: 'gcp',
+            },
+        },
+    },
+    example_code_description: 'Recognize text in an uploaded document and save it to a JSON file:',
+    extended_description: `
+> [!Warning]
+> Transloadit aims to be deterministic, but this <dfn>Robot</dfn> uses third-party AI services. The providers (AWS, GCP) will evolve their models over time, giving different responses for the same input PDFs. Avoid relying on exact responses in your tests and application.
+
+> [!Note]
+> Currently, this <dfn>Robot</dfn> only supports character recognition for PDFs. To use this <dfn>Robot</dfn> with other document formats, use [/document/convert](/docs/robots/document-convert/) first to convert the document into a PDF.
+`,
+    minimum_charge: 1048576,
+    output_factor: 1,
+    override_lvl1: 'Artificial Intelligence',
+    purpose_sentence: 'recognizes text in documents and returns it in a machine-readable format',
+    purpose_verb: 'recognize',
+    purpose_word: 'recognize text',
+    purpose_words: 'Recognize text in documents (OCR)',
+    service_slug: 'artificial-intelligence',
+    slot_count: 10,
+    title: 'Recognize text in documents',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'document',
+    name: 'DocumentOcrRobot',
+    priceFactor: 1,
+    queueSlotCount: 10,
+    minimumChargeUsdPerDocumentOcrPage: {
+        aws: 0.02,
+        gcp: 0.015,
+    },
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+export const robotDocumentOcrInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/document/ocr').describe(`
+With this <dfn>Robot</dfn>, you can detect and extract text from PDFs using optical character recognition (OCR).
+
+For example, you can use the results to obtain the content of invoices, legal documents or restaurant menus. You can also pass the text down to other <dfn>Robots</dfn> to filter documents that contain (or do not contain) certain phrases.
+`),
+    provider: aiProviderSchema.describe(`
+Which AI provider to leverage. Valid values are \`"aws"\` and \`"gcp"\`.
+
+Transloadit outsources this task and abstracts the interface so you can expect the same data structures, but different latencies and information being returned. Different cloud vendors have different areas they shine in, and we recommend to try out and see what yields the best results for your use case.
+
+AWS supports detection for the following languages: English, Arabic, Russian, German, French, Italian, Portuguese and Spanish. GCP allows for a wider range of languages, with varying levels of support which can be found on the [official documentation](https://cloud.google.com/vision/docs/languages/).
+`),
+    granularity: granularitySchema.describe(`
+Whether to return a full response including coordinates for the text (\`"full"\`), or a flat list of the extracted phrases (\`"list"\`). This parameter has no effect if the \`format\` parameter is set to \`"text"\`.
+`),
+    format: z
+        .enum(['json', 'meta', 'text'])
+        .default('json')
+        .describe(`
+In what format to return the extracted text.
+- \`"json"\` returns a JSON file.
+- \`"meta"\` does not return a file, but stores the data inside Transloadit's file object (under \`\${file.meta.recognized_text}\`, which is an array of strings) that's passed around between encoding <dfn>Steps</dfn>, so that you can use the values to burn the data into videos, filter on them, etc.
+- \`"text"\` returns the recognized text as a plain UTF-8 encoded text file.
+`),
+})
+    .strict();
+export const robotDocumentOcrInstructionsWithHiddenFieldsSchema = robotDocumentOcrInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotDocumentOcrInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotDocumentOcrInstructionsSchema = interpolateRobot(robotDocumentOcrInstructionsSchema);
+export const interpolatableRobotDocumentOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentOcrInstructionsWithHiddenFieldsSchema);

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

@@ -0,0 +1,122 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotDocumentSplitInstructionsSchema: z.ZodObject<{
+    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/split">;
+    pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strict>;
+export declare const robotDocumentSplitInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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/split">;
+    pages: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotDocumentSplitInstructions = z.infer<typeof robotDocumentSplitInstructionsSchema>;
+export type RobotDocumentSplitInstructionsWithHiddenFields = z.infer<typeof robotDocumentSplitInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotDocumentSplitInstructionsSchema: z.ZodObject<{
+    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/split">;
+    pages: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString>]>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentSplitInstructions = InterpolatableRobotDocumentSplitInstructionsInput;
+export type InterpolatableRobotDocumentSplitInstructionsInput = z.input<typeof interpolatableRobotDocumentSplitInstructionsSchema>;
+export declare const interpolatableRobotDocumentSplitInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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/split">;
+    pages: z.ZodOptional<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]>>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentSplitInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentSplitInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotDocumentSplitInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentSplitInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=document-split.d.ts.map

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

@@ -0,0 +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,cA2BlB,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-split.js

@@ -0,0 +1,47 @@
+import { z } from 'zod/v4';
+import { interpolateRobot, robotBase, robotUse } from "./_instructions-primitives.js";
+export const meta = {
+    allowed_for_url_transform: true,
+    bytescount: 1,
+    discount_factor: 1,
+    discount_pct: 0,
+    example_code_description: 'Extract single or multiple pages from a PDF document:',
+    minimum_charge: 2097152,
+    output_factor: 1,
+    override_lvl1: 'Document Processing',
+    purpose_sentence: 'extracts pages from documents',
+    purpose_verb: 'extract',
+    purpose_word: 'extracts pages',
+    purpose_words: 'Extracts pages',
+    service_slug: 'document-processing',
+    slot_count: 10,
+    title: 'Extract pages from a document',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'document',
+    name: 'DocumentSplitRobot',
+    priceFactor: 1,
+    queueSlotCount: 10,
+    minimumCharge: 1048576,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+export const robotDocumentSplitInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/document/split'),
+    pages: z
+        .union([z.string(), z.array(z.string())])
+        .describe('The pages to select from the input PDF and to be included in the output PDF. Each entry can be a single page number (e.g. 5), or a range (e.g. `5-10`). Page numbers start at 1. By default all pages are extracted.')
+        .optional(),
+})
+    .strict();
+export const robotDocumentSplitInstructionsWithHiddenFieldsSchema = robotDocumentSplitInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotDocumentSplitInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotDocumentSplitInstructionsSchema = interpolateRobot(robotDocumentSplitInstructionsSchema);
+export const interpolatableRobotDocumentSplitInstructionsWithHiddenFieldsSchema = interpolateRobot(robotDocumentSplitInstructionsWithHiddenFieldsSchema);

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

@@ -0,0 +1,398 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotDocumentThumbsInstructionsSchema: z.ZodObject<{
+    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>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        v3: "v3";
+    }>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/document/thumbs">;
+    page: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        gif: "gif";
+        jpeg: "jpeg";
+        jpg: "jpg";
+        png: "png";
+    }>>;
+    delay: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    resize_strategy: z.ZodDefault<z.ZodEnum<{
+        crop: "crop";
+        fit: "fit";
+        fillcrop: "fillcrop";
+        min_fit: "min_fit";
+        pad: "pad";
+        stretch: "stretch";
+    }>>;
+    background: z.ZodDefault<z.ZodString>;
+    alpha: z.ZodOptional<z.ZodEnum<{
+        Remove: "Remove";
+        Set: "Set";
+    }>>;
+    density: z.ZodOptional<z.ZodString>;
+    antialiasing: z.ZodDefault<z.ZodBoolean>;
+    colorspace: z.ZodOptional<z.ZodEnum<{
+        CMY: "CMY";
+        CMYK: "CMYK";
+        Gray: "Gray";
+        HCL: "HCL";
+        HCLp: "HCLp";
+        HSB: "HSB";
+        HSI: "HSI";
+        HSL: "HSL";
+        HSV: "HSV";
+        HWB: "HWB";
+        Jzazbz: "Jzazbz";
+        Lab: "Lab";
+        LCHab: "LCHab";
+        LCHuv: "LCHuv";
+        LMS: "LMS";
+        Log: "Log";
+        Luv: "Luv";
+        OHTA: "OHTA";
+        OkLab: "OkLab";
+        OkLCH: "OkLCH";
+        Rec601YCbCr: "Rec601YCbCr";
+        Rec709YCbCr: "Rec709YCbCr";
+        RGB: "RGB";
+        scRGB: "scRGB";
+        sRGB: "sRGB";
+        Transparent: "Transparent";
+        Undefined: "Undefined";
+        xyY: "xyY";
+        XYZ: "XYZ";
+        YCbCr: "YCbCr";
+        YCC: "YCC";
+        YDbDr: "YDbDr";
+        YIQ: "YIQ";
+        YPbPr: "YPbPr";
+        YUV: "YUV";
+    }>>;
+    trim_whitespace: z.ZodDefault<z.ZodBoolean>;
+    pdf_use_cropbox: z.ZodDefault<z.ZodBoolean>;
+    turbo: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const robotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<readonly [z.ZodEnum<{
+        v3: "v3";
+    }>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/document/thumbs">;
+    page: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        gif: "gif";
+        jpeg: "jpeg";
+        jpg: "jpg";
+        png: "png";
+    }>>;
+    delay: z.ZodOptional<z.ZodNumber>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodDefault<z.ZodString>;
+    density: z.ZodOptional<z.ZodString>;
+    antialiasing: z.ZodDefault<z.ZodBoolean>;
+    colorspace: z.ZodOptional<z.ZodEnum<{
+        CMY: "CMY";
+        CMYK: "CMYK";
+        Gray: "Gray";
+        HCL: "HCL";
+        HCLp: "HCLp";
+        HSB: "HSB";
+        HSI: "HSI";
+        HSL: "HSL";
+        HSV: "HSV";
+        HWB: "HWB";
+        Jzazbz: "Jzazbz";
+        Lab: "Lab";
+        LCHab: "LCHab";
+        LCHuv: "LCHuv";
+        LMS: "LMS";
+        Log: "Log";
+        Luv: "Luv";
+        OHTA: "OHTA";
+        OkLab: "OkLab";
+        OkLCH: "OkLCH";
+        Rec601YCbCr: "Rec601YCbCr";
+        Rec709YCbCr: "Rec709YCbCr";
+        RGB: "RGB";
+        scRGB: "scRGB";
+        sRGB: "sRGB";
+        Transparent: "Transparent";
+        Undefined: "Undefined";
+        xyY: "xyY";
+        XYZ: "XYZ";
+        YCbCr: "YCbCr";
+        YCC: "YCC";
+        YDbDr: "YDbDr";
+        YIQ: "YIQ";
+        YPbPr: "YPbPr";
+        YUV: "YUV";
+    }>>;
+    trim_whitespace: z.ZodDefault<z.ZodBoolean>;
+    pdf_use_cropbox: z.ZodDefault<z.ZodBoolean>;
+    turbo: z.ZodDefault<z.ZodBoolean>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+    stack: z.ZodOptional<z.ZodString>;
+    alpha: z.ZodOptional<z.ZodEnum<{
+        set: "set";
+        remove: "remove";
+        Remove: "Remove";
+        Set: "Set";
+    }>>;
+    resize_strategy: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        crop: "crop";
+        fit: "fit";
+        fillcrop: "fillcrop";
+        min_fit: "min_fit";
+        pad: "pad";
+        stretch: "stretch";
+    }>>;
+}, z.core.$strict>;
+export type RobotDocumentThumbsInstructions = z.infer<typeof robotDocumentThumbsInstructionsSchema>;
+export type RobotDocumentThumbsInstructionsWithHiddenFields = z.infer<typeof robotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotDocumentThumbsInstructionsSchema: z.ZodObject<{
+    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>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        v3: "v3";
+    }>]>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/document/thumbs">;
+    page: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        gif: "gif";
+        jpeg: "jpeg";
+        jpg: "jpg";
+        png: "png";
+    }>]>>;
+    delay: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    resize_strategy: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        crop: "crop";
+        fit: "fit";
+        fillcrop: "fillcrop";
+        min_fit: "min_fit";
+        pad: "pad";
+        stretch: "stretch";
+    }>]>>;
+    background: z.ZodDefault<z.ZodString>;
+    alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        Remove: "Remove";
+        Set: "Set";
+    }>]>>;
+    density: z.ZodOptional<z.ZodString>;
+    antialiasing: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    colorspace: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        CMY: "CMY";
+        CMYK: "CMYK";
+        Gray: "Gray";
+        HCL: "HCL";
+        HCLp: "HCLp";
+        HSB: "HSB";
+        HSI: "HSI";
+        HSL: "HSL";
+        HSV: "HSV";
+        HWB: "HWB";
+        Jzazbz: "Jzazbz";
+        Lab: "Lab";
+        LCHab: "LCHab";
+        LCHuv: "LCHuv";
+        LMS: "LMS";
+        Log: "Log";
+        Luv: "Luv";
+        OHTA: "OHTA";
+        OkLab: "OkLab";
+        OkLCH: "OkLCH";
+        Rec601YCbCr: "Rec601YCbCr";
+        Rec709YCbCr: "Rec709YCbCr";
+        RGB: "RGB";
+        scRGB: "scRGB";
+        sRGB: "sRGB";
+        Transparent: "Transparent";
+        Undefined: "Undefined";
+        xyY: "xyY";
+        XYZ: "XYZ";
+        YCbCr: "YCbCr";
+        YCC: "YCC";
+        YDbDr: "YDbDr";
+        YIQ: "YIQ";
+        YPbPr: "YPbPr";
+        YUV: "YUV";
+    }>]>>;
+    trim_whitespace: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    pdf_use_cropbox: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    turbo: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentThumbsInstructions = InterpolatableRobotDocumentThumbsInstructionsInput;
+export type InterpolatableRobotDocumentThumbsInstructionsInput = z.input<typeof interpolatableRobotDocumentThumbsInstructionsSchema>;
+export declare const interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    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>]>>;
+    imagemagick_stack: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        v3: "v3";
+    }>]>, z.ZodString]>>;
+    robot: z.ZodLiteral<"/document/thumbs">;
+    page: z.ZodDefault<z.ZodNullable<z.ZodUnion<[z.ZodString, z.ZodNumber]>>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        gif: "gif";
+        jpeg: "jpeg";
+        jpg: "jpg";
+        png: "png";
+    }>]>>;
+    delay: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    background: z.ZodDefault<z.ZodString>;
+    density: z.ZodOptional<z.ZodString>;
+    antialiasing: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    colorspace: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        CMY: "CMY";
+        CMYK: "CMYK";
+        Gray: "Gray";
+        HCL: "HCL";
+        HCLp: "HCLp";
+        HSB: "HSB";
+        HSI: "HSI";
+        HSL: "HSL";
+        HSV: "HSV";
+        HWB: "HWB";
+        Jzazbz: "Jzazbz";
+        Lab: "Lab";
+        LCHab: "LCHab";
+        LCHuv: "LCHuv";
+        LMS: "LMS";
+        Log: "Log";
+        Luv: "Luv";
+        OHTA: "OHTA";
+        OkLab: "OkLab";
+        OkLCH: "OkLCH";
+        Rec601YCbCr: "Rec601YCbCr";
+        Rec709YCbCr: "Rec709YCbCr";
+        RGB: "RGB";
+        scRGB: "scRGB";
+        sRGB: "sRGB";
+        Transparent: "Transparent";
+        Undefined: "Undefined";
+        xyY: "xyY";
+        XYZ: "XYZ";
+        YCbCr: "YCbCr";
+        YCC: "YCC";
+        YDbDr: "YDbDr";
+        YIQ: "YIQ";
+        YPbPr: "YPbPr";
+        YUV: "YUV";
+    }>]>>;
+    trim_whitespace: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    pdf_use_cropbox: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    turbo: 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]>>]>>;
+    stack: z.ZodOptional<z.ZodString>;
+    alpha: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        set: "set";
+        remove: "remove";
+        Remove: "Remove";
+        Set: "Set";
+    }>]>>;
+    resize_strategy: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        none: "none";
+        crop: "crop";
+        fit: "fit";
+        fillcrop: "fillcrop";
+        min_fit: "min_fit";
+        pad: "pad";
+        stretch: "stretch";
+    }>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotDocumentThumbsInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=document-thumbs.d.ts.map

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

@@ -0,0 +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,cAwClB,CAAA;AAED,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA6HvC,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"}