@transloadit/zod 4.3.0 → 4.3.2

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

@@ -2,6 +2,7 @@ import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -58,10 +59,16 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     }>]>>;
 } & {
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodEnum<["jpg", "png"]>>;
+    format: z.ZodDefault<z.ZodEnum<["jpg", "png", "webp"]>>;
     direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical"]>>;
+    effect: z.ZodOptional<z.ZodEnum<["mosaic", "polaroid-stack"]>>;
     border: z.ZodDefault<z.ZodNumber>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
@@ -70,11 +77,14 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     force_accept: boolean;
     ignore_errors: string[];
     background: string;
-    format: "jpg" | "png";
-    direction: "horizontal" | "vertical";
+    format: "jpg" | "png" | "webp";
+    quality: number;
+    direction: "vertical" | "horizontal";
     border: number;
+    shuffle: boolean;
     adaptive_filtering: boolean;
-    quality: number;
+    effect?: "mosaic" | "polaroid-stack" | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -91,8 +101,14 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     } | undefined;
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     queue?: "batch" | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    seed?: number | undefined;
+    coverage?: number | undefined;
 }, {
     robot: "/image/merge";
+    effect?: "mosaic" | "polaroid-stack" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -112,14 +128,20 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
     background?: string | undefined;
-    format?: "jpg" | "png" | undefined;
-    direction?: "horizontal" | "vertical" | undefined;
+    format?: "jpg" | "png" | "webp" | undefined;
+    quality?: number | undefined;
+    seed?: number | undefined;
+    direction?: "vertical" | "horizontal" | undefined;
     border?: number | undefined;
+    shuffle?: boolean | undefined;
+    coverage?: number | undefined;
     adaptive_filtering?: boolean | undefined;
-    quality?: number | undefined;
 }>;
 export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -173,10 +195,16 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodEnum<["jpg", "png"]>>;
+    format: z.ZodDefault<z.ZodEnum<["jpg", "png", "webp"]>>;
     direction: z.ZodDefault<z.ZodEnum<["horizontal", "vertical"]>>;
+    effect: z.ZodOptional<z.ZodEnum<["mosaic", "polaroid-stack"]>>;
     border: z.ZodDefault<z.ZodNumber>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>>;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    shuffle: z.ZodDefault<z.ZodBoolean>;
+    coverage: z.ZodOptional<z.ZodNumber>;
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
 } & {
@@ -186,11 +214,14 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     force_accept: boolean;
     ignore_errors: string[];
     background: string;
-    format: "jpg" | "png";
-    direction: "horizontal" | "vertical";
+    format: "jpg" | "png" | "webp";
+    quality: number;
+    direction: "vertical" | "horizontal";
     border: number;
+    shuffle: boolean;
     adaptive_filtering: boolean;
-    quality: number;
+    effect?: "mosaic" | "polaroid-stack" | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -208,8 +239,14 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     output_meta?: boolean | string[] | Record<string, boolean> | undefined;
     result?: boolean | "debug" | undefined;
     queue?: "batch" | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
+    seed?: number | undefined;
+    coverage?: number | undefined;
 }, {
     robot: "/image/merge";
+    effect?: "mosaic" | "polaroid-stack" | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -229,16 +266,22 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     queue?: "batch" | undefined;
     force_accept?: boolean | undefined;
     ignore_errors?: boolean | ("meta" | "execute")[] | undefined;
+    width?: number | undefined;
+    height?: number | undefined;
     background?: string | undefined;
-    format?: "jpg" | "png" | undefined;
-    direction?: "horizontal" | "vertical" | undefined;
+    format?: "jpg" | "png" | "webp" | undefined;
+    quality?: number | undefined;
+    seed?: number | undefined;
+    direction?: "vertical" | "horizontal" | undefined;
     border?: number | undefined;
+    shuffle?: boolean | undefined;
+    coverage?: number | undefined;
     adaptive_filtering?: boolean | undefined;
-    quality?: number | undefined;
 }>;
 export type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>;
 export type RobotImageMergeInstructionsWithHiddenFields = z.infer<typeof robotImageMergeInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -293,10 +336,16 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png"]>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "webp"]>]>>;
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical"]>]>>;
+    effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["mosaic", "polaroid-stack"]>]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>]>>;
+    width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     adaptive_filtering: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     quality: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
 }, "strict", z.ZodTypeAny, {
@@ -306,10 +355,13 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     ignore_errors: string | string[];
     background: string;
     format: string;
+    quality: string | number;
     direction: string;
     border: string | number;
+    shuffle: string | boolean;
     adaptive_filtering: string | boolean;
-    quality: string | number;
+    effect?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -326,8 +378,14 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     } | undefined;
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     queue?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    seed?: string | number | undefined;
+    coverage?: string | number | undefined;
 }, {
     robot: "/image/merge";
+    effect?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -347,16 +405,22 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
     background?: string | undefined;
     format?: string | undefined;
+    quality?: string | number | undefined;
+    seed?: string | number | undefined;
     direction?: string | undefined;
     border?: string | number | undefined;
+    shuffle?: string | boolean | undefined;
+    coverage?: string | number | undefined;
     adaptive_filtering?: string | boolean | undefined;
-    quality?: string | number | undefined;
 }>;
 export type InterpolatableRobotImageMergeInstructions = InterpolatableRobotImageMergeInstructionsInput;
 export type InterpolatableRobotImageMergeInstructionsInput = z.input<typeof interpolatableRobotImageMergeInstructionsSchema>;
 export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -410,10 +474,16 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
         group_by_original?: boolean | undefined;
     }>]>>;
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png"]>]>>;
+    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["jpg", "png", "webp"]>]>>;
     direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<["horizontal", "vertical"]>]>>;
+    effect: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["mosaic", "polaroid-stack"]>]>>;
     border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodString>;
+    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<["transparent", "none", "black", "white", "red", "green", "blue", "yellow", "cyan", "magenta", "gray", "grey", "opaque"]>]>]>>;
+    width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    seed: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    shuffle: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    coverage: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     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]>>]>>;
@@ -423,10 +493,13 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     ignore_errors: string | string[];
     background: string;
     format: string;
+    quality: string | number;
     direction: string;
     border: string | number;
+    shuffle: string | boolean;
     adaptive_filtering: string | boolean;
-    quality: string | number;
+    effect?: string | undefined;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -444,8 +517,14 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     output_meta?: string | boolean | string[] | Record<string, string | boolean> | undefined;
     result?: string | boolean | undefined;
     queue?: string | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
+    seed?: string | number | undefined;
+    coverage?: string | number | undefined;
 }, {
     robot: "/image/merge";
+    effect?: string | undefined;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -465,12 +544,17 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     queue?: string | undefined;
     force_accept?: string | boolean | undefined;
     ignore_errors?: string | boolean | ("meta" | "execute")[] | undefined;
+    width?: string | number | undefined;
+    height?: string | number | undefined;
     background?: string | undefined;
     format?: string | undefined;
+    quality?: string | number | undefined;
+    seed?: string | number | undefined;
     direction?: string | undefined;
     border?: string | number | undefined;
+    shuffle?: string | boolean | undefined;
+    coverage?: string | number | undefined;
     adaptive_filtering?: string | boolean | undefined;
-    quality?: string | number | undefined;
 }>;
 export type InterpolatableRobotImageMergeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,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"}
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v3/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAQnE,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgHnC,CAAA;AAEX,eAAO,MAAM,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAK1D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3D,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE3E,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/v3/robots/image-merge.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
-import { color_without_alpha, imageQualitySchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { color_without_alpha_with_named, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
 export const meta = {
-    allowed_for_url_transform: true,
     bytescount: 1,
     discount_factor: 1,
     discount_pct: 0,
@@ -49,13 +48,25 @@ It's recommended to use this Robot with
 similar size before merging them.
 `),
     format: z
-        .enum(['jpg', 'png'])
+        .enum(['jpg', 'png', 'webp'])
         .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.'),
+        .describe(`
+Specifies the direction which the images are displayed.
+
+Only applies to the default spritesheet layout. Ignored when \`effect\` is set to \`polaroid-stack\` or \`mosaic\`, as those effects use their own layout algorithms.
+`),
+    effect: z
+        .enum(['mosaic', 'polaroid-stack'])
+        .optional()
+        .describe(`
+Applies a styled collage layout instead of a plain horizontal or vertical spritesheet.
+
+Currently supports \`polaroid-stack\`, which renders the inputs as overlapping instant photos on a canvas, and \`mosaic\`, which builds a justified tiled collage.
+`),
     // TODO: default is not between 1 and 10
     border: z
         .number()
@@ -65,13 +76,62 @@ similar size before merging them.
 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.
+
+When \`effect\` is \`polaroid-stack\`, this value is instead used as canvas padding so the outermost photos keep that many pixels of distance from the edge.
+
+When \`effect\` is \`mosaic\`, this value is used both as the outer canvas padding and as the gutter width between neighbouring tiles.
 `),
-    background: color_without_alpha.default('#FFFFFF').describe(`
+    background: color_without_alpha_with_named.default('#fff').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.
+By default, the background of transparent images is changed to white. Set to \`none\` or \`transparent\` for a transparent canvas — requires \`format\` \`png\` or \`webp\` to preserve alpha.
 
 For details about how to preserve transparency across all image types, see [this demo](/demos/image-manipulation/properly-preserve-transparency-across-all-image-types/).
+`),
+    width: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(`
+The output canvas width in pixels.
+
+This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    height: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe(`
+The output canvas height in pixels.
+
+This is mainly used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    seed: z
+        .number()
+        .int()
+        .optional()
+        .describe(`
+Optional deterministic seed used by styled effects such as \`polaroid-stack\` and \`mosaic\`.
+`),
+    shuffle: z
+        .boolean()
+        .default(false)
+        .describe(`
+Whether styled effects such as \`polaroid-stack\` and \`mosaic\` may shuffle the input order before laying out the canvas.
+`),
+    coverage: z
+        .number()
+        .min(0.5)
+        .max(3)
+        .optional()
+        .describe(`
+Area-coverage multiplier for the \`polaroid-stack\` effect. Controls how large each polaroid is relative to the canvas and consequently how much of the canvas is covered by photos.
+
+The default of \`1.5\` leaves a subtle beige border along some edges. Use \`2.0\`–\`2.5\` for edge-to-edge coverage (photos overlap more). Values below \`1.0\` produce smaller, more widely spaced polaroids.
+
+Has no effect on the \`mosaic\` style or on plain spritesheets.
 `),
     adaptive_filtering: z
         .boolean()
@@ -79,7 +139,15 @@ For details about how to preserve transparency across all image types, see [this
         .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,
+    quality: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .default(100)
+        .describe(`
+Controls the image compression for JPG, PNG, and WebP images. Please also take a look at [🤖/image/optimize](/docs/robots/image-optimize/).
+`),
 })
     .strict();
 export const robotImageMergeInstructionsWithHiddenFieldsSchema = robotImageMergeInstructionsSchema.extend({

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

@@ -2,6 +2,7 @@ import { z } from 'zod/v3';
 import type { RobotMetaInput } from './_instructions-primitives.ts';
 export declare const meta: RobotMetaInput;
 export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
@@ -69,6 +70,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     format: "meta" | "text" | "json";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
     granularity: "full" | "list";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -88,6 +90,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
 }, {
     robot: "/image/ocr";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -111,6 +114,7 @@ export declare const robotImageOcrInstructionsSchema: z.ZodObject<{
     granularity?: "full" | "list" | undefined;
 }>;
 export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString, "many">]>>;
     queue: z.ZodOptional<z.ZodEnum<["batch"]>>;
     force_accept: z.ZodDefault<z.ZodBoolean>;
@@ -176,6 +180,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
     format: "meta" | "text" | "json";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
     granularity: "full" | "list";
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -196,6 +201,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
 }, {
     robot: "/image/ocr";
     provider: "aws" | "gcp" | "replicate" | "fal" | "transloadit";
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -221,6 +227,7 @@ export declare const robotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObjec
 export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>;
 export type RobotImageOcrInstructionsWithHiddenFields = z.infer<typeof robotImageOcrInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
     result: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
@@ -286,6 +293,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
     format: string;
     provider: string;
     granularity: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -305,6 +313,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
 }, {
     robot: "/image/ocr";
     provider: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -330,6 +339,7 @@ export declare const interpolatableRobotImageOcrInstructionsSchema: z.ZodObject<
 export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput;
 export type InterpolatableRobotImageOcrInstructionsInput = z.input<typeof interpolatableRobotImageOcrInstructionsSchema>;
 export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    interpolate: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, boolean, boolean | "false" | "true">, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["true", "false"]>]>, 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, "many">]>]>>;
     queue: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodEnum<["batch"]>]>>;
     force_accept: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
@@ -394,6 +404,7 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
     format: string;
     provider: string;
     granularity: string;
+    interpolate?: boolean | Record<string, boolean> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;
@@ -414,6 +425,7 @@ export declare const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSche
 }, {
     robot: "/image/ocr";
     provider: string;
+    interpolate?: boolean | "false" | "true" | Record<string, boolean | "false" | "true"> | undefined;
     use?: string | string[] | {
         name: string;
         fields?: string | undefined;

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

@@ -1 +1 @@
-{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,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"}
+{"version":3,"file":"image-ocr.d.ts","sourceRoot":"","sources":["../../../src/v3/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,cAwClB,CAAA;AAED,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BjC,CAAA;AAEX,eAAO,MAAM,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzD,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,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/v3/robots/image-ocr.js

@@ -1,7 +1,6 @@
 import { z } from 'zod/v3';
 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,