@transloadit/zod 4.1.5 → 4.1.7

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

@@ -0,0 +1,166 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotImageMergeInstructionsSchema: 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<"/image/merge">;
+    format: z.ZodDefault<z.ZodEnum<{
+        jpg: "jpg";
+        png: "png";
+    }>>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        horizontal: "horizontal";
+        vertical: "vertical";
+    }>>;
+    border: z.ZodDefault<z.ZodNumber>;
+    background: z.ZodDefault<z.ZodString>;
+    adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
+    quality: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: 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<"/image/merge">;
+    format: z.ZodDefault<z.ZodEnum<{
+        jpg: "jpg";
+        png: "png";
+    }>>;
+    direction: z.ZodDefault<z.ZodEnum<{
+        horizontal: "horizontal";
+        vertical: "vertical";
+    }>>;
+    border: z.ZodDefault<z.ZodNumber>;
+    background: z.ZodDefault<z.ZodString>;
+    adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
+    quality: z.ZodDefault<z.ZodNumber>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>;
+export type RobotImageMergeInstructionsWithHiddenFields = z.infer<typeof robotImageMergeInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotImageMergeInstructionsSchema: 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<"/image/merge">;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        jpg: "jpg";
+        png: "png";
+    }>]>>;
+    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        horizontal: "horizontal";
+        vertical: "vertical";
+    }>]>>;
+    border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    background: z.ZodDefault<z.ZodString>;
+    adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotImageMergeInstructions = InterpolatableRobotImageMergeInstructionsInput;
+export type InterpolatableRobotImageMergeInstructionsInput = z.input<typeof interpolatableRobotImageMergeInstructionsSchema>;
+export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema: 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<"/image/merge">;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        jpg: "jpg";
+        png: "png";
+    }>]>>;
+    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        horizontal: "horizontal";
+        vertical: "vertical";
+    }>]>>;
+    border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    background: z.ZodDefault<z.ZodString>;
+    adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    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 InterpolatableRobotImageMergeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=image-merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.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,cAsClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2CnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK1D,CAAA;AAEJ,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iCAAiC,CAAC,CAAA;AAC3F,MAAM,MAAM,2CAA2C,GAAG,CAAC,CAAC,KAAK,CAC/D,OAAO,iDAAiD,CACzD,CAAA;AAED,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3D,CAAA;AACD,MAAM,MAAM,yCAAyC,GACnD,8CAA8C,CAAA;AAEhD,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE3E,CAAA;AACD,MAAM,MAAM,yDAAyD,GAAG,CAAC,CAAC,KAAK,CAC7E,OAAO,+DAA+D,CACvE,CAAA;AACD,MAAM,MAAM,8DAA8D,GAAG,CAAC,CAAC,KAAK,CAClF,OAAO,+DAA+D,CACvE,CAAA"}

package/dist/v4/robots/image-merge.js

@@ -0,0 +1,91 @@
+import { z } from 'zod/v4';
+import { color_without_alpha, imageQualitySchema, 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: {
+            merged: {
+                robot: '/image/merge',
+                use: {
+                    steps: [':original'],
+                    bundle_steps: true,
+                },
+                border: 5,
+            },
+        },
+    },
+    example_code_description: 'Merge uploaded images into one, with a 5px gap between them on the spritesheet:',
+    minimum_charge: 0,
+    output_factor: 0.6,
+    override_lvl1: 'Image Manipulation',
+    purpose_sentence: 'merges several images into a single spritesheet',
+    purpose_verb: 'merge',
+    purpose_word: 'merge',
+    purpose_words: 'Merge several images into one image',
+    service_slug: 'image-manipulation',
+    slot_count: 10,
+    title: 'Merge several images into a single image',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'image',
+    name: 'ImageMergeRobot',
+    priceFactor: 1,
+    queueSlotCount: 10,
+    isAllowedForUrlTransform: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+export const robotImageMergeInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/image/merge').describe(`
+The final result will be a spritesheet, with the images displayed horizontally or vertically.
+
+It's recommended to use this Robot with
+[🤖/image/resize](/docs/robots/image-resize/) so your images are of a
+similar size before merging them.
+`),
+    format: z
+        .enum(['jpg', 'png'])
+        .default('png')
+        .describe('The output format for the modified image.'),
+    direction: z
+        .enum(['horizontal', 'vertical'])
+        .default('horizontal')
+        .describe('Specifies the direction which the images are displayed.'),
+    // TODO: default is not between 1 and 10
+    border: z
+        .number()
+        .int()
+        .default(0)
+        .describe(`
+An integer value which defines the gap between images on the spritesheet.
+
+A value of \`10\` would cause the images to have the largest gap between them, while a value of \`1\` would place the images side-by-side.
+`),
+    background: color_without_alpha.default('#FFFFFF').describe(`
+Either the hexadecimal code or [name](https://www.imagemagick.org/script/color.php#color_names) of the color used to fill the background (only shown with a border > 1).
+
+By default, the background of transparent images is changed to white.
+
+For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+`),
+    adaptive_filtering: z
+        .boolean()
+        .default(false)
+        .describe(`
+Controls the image compression for PNG images. Setting to \`true\` results in smaller file size, while increasing processing time. It is encouraged to keep this option disabled.
+`),
+    quality: imageQualitySchema,
+})
+    .strict();
+export const robotImageMergeInstructionsWithHiddenFieldsSchema = robotImageMergeInstructionsSchema.extend({
+    result: z
+        .union([z.literal('debug'), robotImageMergeInstructionsSchema.shape.result])
+        .optional(),
+});
+export const interpolatableRobotImageMergeInstructionsSchema = interpolateRobot(robotImageMergeInstructionsSchema);
+export const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageMergeInstructionsWithHiddenFieldsSchema);

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

@@ -0,0 +1,182 @@
+import { z } from 'zod/v4';
+import type { RobotMetaInput } from './_instructions-primitives.ts';
+export declare const meta: RobotMetaInput;
+export declare const robotImageOcrInstructionsSchema: 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<"/image/ocr">;
+    provider: z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+        replicate: "replicate";
+        fal: "fal";
+        transloadit: "transloadit";
+    }>;
+    granularity: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        list: "list";
+    }>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        meta: "meta";
+        text: "text";
+        json: "json";
+    }>>;
+}, z.core.$strict>;
+export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: 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<"/image/ocr">;
+    provider: z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+        replicate: "replicate";
+        fal: "fal";
+        transloadit: "transloadit";
+    }>;
+    granularity: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        list: "list";
+    }>>;
+    format: z.ZodDefault<z.ZodEnum<{
+        meta: "meta";
+        text: "text";
+        json: "json";
+    }>>;
+    result: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"debug">, z.ZodDefault<z.ZodBoolean>]>>;
+}, z.core.$strict>;
+export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
+export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
+export declare const interpolatableRobotImageOcrInstructionsSchema: 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<"/image/ocr">;
+    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+        replicate: "replicate";
+        fal: "fal";
+        transloadit: "transloadit";
+    }>]>;
+    granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        full: "full";
+        list: "list";
+    }>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        meta: "meta";
+        text: "text";
+        json: "json";
+    }>]>>;
+}, z.core.$strict>;
+export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
+export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
+export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: 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<"/image/ocr">;
+    provider: z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        aws: "aws";
+        gcp: "gcp";
+        replicate: "replicate";
+        fal: "fal";
+        transloadit: "transloadit";
+    }>]>;
+    granularity: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        full: "full";
+        list: "list";
+    }>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+        meta: "meta";
+        text: "text";
+        json: "json";
+    }>]>>;
+    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 InterpolatableRobotImageOcrInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema>;
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema>;
+//# sourceMappingURL=image-ocr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-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,cAyClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAGxD,CAAA;AAEJ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAA;AACvF,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,KAAK,CAC7D,OAAO,+CAA+C,CACvD,CAAA;AAED,eAAO,MAAM,6CAA6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzD,CAAA;AACD,MAAM,MAAM,uCAAuC,GAAG,4CAA4C,CAAA;AAElG,MAAM,MAAM,4CAA4C,GAAG,CAAC,CAAC,KAAK,CAChE,OAAO,6CAA6C,CACrD,CAAA;AAED,eAAO,MAAM,6DAA6D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAEzE,CAAA;AACD,MAAM,MAAM,uDAAuD,GAAG,CAAC,CAAC,KAAK,CAC3E,OAAO,6DAA6D,CACrE,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,6DAA6D,CACrE,CAAA"}

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

@@ -0,0 +1,78 @@
+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: '/image/ocr',
+                use: ':original',
+                provider: 'gcp',
+                format: 'text',
+            },
+        },
+    },
+    example_code_description: 'Recognize text in an uploaded image and save it to a text 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 images. Avoid relying on exact responses in your tests and application.
+`,
+    minimum_charge: 1048576,
+    output_factor: 0.6,
+    override_lvl1: 'Artificial Intelligence',
+    purpose_sentence: 'recognizes text in images and returns it in a machine-readable format',
+    purpose_verb: 'recognize',
+    purpose_word: 'recognize text',
+    purpose_words: 'Recognize text in images (OCR)',
+    service_slug: 'artificial-intelligence',
+    slot_count: 10,
+    title: 'Recognize text in images',
+    typical_file_size_mb: 0.8,
+    typical_file_type: 'image',
+    name: 'ImageOcrRobot',
+    priceFactor: 1,
+    queueSlotCount: 10,
+    minimumChargeUsd: 0.0013,
+    isAllowedForUrlTransform: true,
+    trackOutputFileSize: true,
+    isInternal: false,
+    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
+    stage: 'ga',
+};
+export const robotImageOcrInstructionsSchema = robotBase
+    .merge(robotUse)
+    .extend({
+    robot: z.literal('/image/ocr').describe(`
+With this <dfn>Robot</dfn> you can detect and extract text from images using optical character recognition (OCR).
+
+For example, you can use the results to obtain the content of traffic signs, name tags, package labels and many more. You can also pass the text down to other <dfn>Robots</dfn> to filter images that contain (or do not contain) certain phrases. For images of dense documents, results may vary and be less accurate than for small pieces of text in photos.
+`),
+    provider: aiProviderSchema.describe(`
+Which AI provider to leverage.
+
+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 robotImageOcrInstructionsWithHiddenFieldsSchema = robotImageOcrInstructionsSchema.extend({
+    result: z.union([z.literal('debug'), robotImageOcrInstructionsSchema.shape.result]).optional(),
+});
+export const interpolatableRobotImageOcrInstructionsSchema = interpolateRobot(robotImageOcrInstructionsSchema);
+export const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageOcrInstructionsWithHiddenFieldsSchema);