@transloadit/zod 4.5.0 → 5.0.1

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

@@ -1,5 +1,6 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { autoProviderDescription, awsGcpAiProviderSchema, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { awsGcpAiProviderSchema, createProcessingExample, defineRobot, robotArtificialIntelligenceMeta, robotBase, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
 export const imageFacedetectFaceSelectionModes = [
     'each',
     'group',
@@ -9,52 +10,33 @@ export const imageFacedetectFaceSelectionModes = [
 export const imageFacedetectFaceSelectionModeSchema = z.enum(imageFacedetectFaceSelectionModes);
 export const imageFacedetectFaceCoordinatesSchema = z
     .object({
-    confidence: z.number().optional(),
+    confidence: optionalWithV3Semantics(z.number()),
     height: z.number(),
     width: z.number(),
     x1: z.number(),
-    x2: z.number().optional(),
+    x2: optionalWithV3Semantics(z.number()),
     y1: z.number(),
-    y2: z.number().optional(),
+    y2: optionalWithV3Semantics(z.number()),
 })
     .catchall(z.unknown());
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
-    example_code: {
-        steps: {
-            faces_detected: {
-                robot: '/image/facedetect',
-                use: ':original',
-                crop: true,
-                faces: 'each',
-                crop_padding: '10px',
-            },
-        },
-    },
+    ...robotArtificialIntelligenceMeta,
+    example_code: createProcessingExample('faces_detected', '/image/facedetect', {
+        crop: true,
+        faces: 'each',
+        crop_padding: '10px',
+    }),
     example_code_description: 'Detect all faces in uploaded images, crop them, and save as separate images:',
-    minimum_charge: 5242880,
-    output_factor: 0.2,
     override_lvl1: 'Artificial Intelligence',
     purpose_sentence: 'detects faces in images and can return either their coordinates or the faces themselves as new images',
     purpose_verb: 'detect',
     purpose_word: 'detect faces',
     purpose_words: 'Detect faces in images',
-    service_slug: 'artificial-intelligence',
-    slot_count: 20,
     title: 'Detect faces in images',
     typical_file_size_mb: 0.8,
-    typical_file_type: 'image',
     name: 'ImageFacedetectRobot',
-    priceFactor: 1,
     queueSlotCount: 20,
     minimumChargeUsd: 0.0013,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 export const robotImageFacedetectInstructionsSchema = robotBase
     .merge(robotUse)
@@ -74,11 +56,7 @@ This <dfn>Robot</dfn> works well together with [🤖/image/resize](/docs/robots/
 
 </div>
 `),
-    provider: awsGcpAiProviderSchema.describe(`
-${autoProviderDescription}
-
-Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
-`),
+    provider: awsGcpAiProviderSchema.describe(robotParameterDocs.ai_provider.description),
     crop: z
         .boolean()
         .default(false)
@@ -87,7 +65,7 @@ Determine if the detected faces should be extracted. If this option is set to \`
 `),
     crop_padding: z
         .string()
-        .regex(/^\d+(px|%)$/)
+        .regex(/^[0-9]+(px|%)$/u)
         .default('5px')
         .describe(`
 Specifies how much padding is added to the extracted face images if \`crop\` is set to \`true\`. Values can be in \`px\` (pixels) or \`%\` (percentage of the width and height of the particular face image).
@@ -125,32 +103,32 @@ For the following examples, the input image is:
 
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-unsplash.jpg)
 
-<br>
+<br />
 
 \`faces: "each"\` applied:
 
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-0.jpg)
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
 
-<br>
+<br />
 
 \`faces: "max-confidence"\` applied:
 
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
 
-<br>
+<br />
 
 \`faces: "max-size"\` applied:
 
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-1.jpg)
 
-<br>
+<br />
 
 \`faces: "group"\` applied:
 
 ![](/assets/images/abbas-malek-hosseini-22NnY93qaOk-face-group.jpg)
 
-<br>
+<br />
 
 \`faces: 0\` applied:
 
@@ -158,10 +136,5 @@ For the following examples, the input image is:
 `),
 })
     .strict();
-export const robotImageFacedetectInstructionsWithHiddenFieldsSchema = robotImageFacedetectInstructionsSchema.extend({
-    result: z
-        .union([z.literal('debug'), robotImageFacedetectInstructionsSchema.shape.result])
-        .optional(),
-});
-export const interpolatableRobotImageFacedetectInstructionsSchema = interpolateRobot(robotImageFacedetectInstructionsSchema);
-export const interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageFacedetectInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = defineRobot(meta, robotImageFacedetectInstructionsSchema);
+export const { withHiddenFields: robotImageFacedetectInstructionsWithHiddenFieldsSchema, interpolatable: interpolatableRobotImageFacedetectInstructionsSchema, interpolatableWithHiddenFields: interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema, } = robotDefinition;

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -53,13 +54,14 @@ export declare const robotImageGenerateInstructionsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export declare const robotImageGenerateInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -106,18 +108,20 @@ export type RobotImageGenerateInstructions = z.infer<typeof robotImageGenerateIn
 export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof robotImageGenerateInstructionsWithHiddenFieldsSchema>;
 export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -152,25 +156,24 @@ export declare const interpolatableRobotImageGenerateInstructionsSchema: z.ZodOb
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodDefault<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 InterpolatableRobotImageGenerateInstructions = InterpolatableRobotImageGenerateInstructionsInput;
 export type InterpolatableRobotImageGenerateInstructionsInput = z.input<typeof interpolatableRobotImageGenerateInstructionsSchema>;
 export declare const interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -205,9 +208,10 @@ export declare const interpolatableRobotImageGenerateInstructionsWithHiddenField
     width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     style: z.ZodOptional<z.ZodString>;
     num_outputs: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    provider: z.ZodDefault<z.ZodString>;
-    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
+    provider: z.ZodPrefault<z.ZodString>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
 export type InterpolatableRobotImageGenerateInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema>;
 export type InterpolatableRobotImageGenerateInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema>;
+export declare const robotDefinition: RobotSchemaPair<typeof interpolatableRobotImageGenerateInstructionsSchema, typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema>;
 //# sourceMappingURL=image-generate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAS1B,eAAO,MAAM,IAAI,EAAE,cA4ClB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAsEtC,CAAA;AAEX,eAAO,MAAM,oDAAoD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAM7D,CAAA;AAEJ,MAAM,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oCAAoC,CAAC,CAAA;AACjG,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,KAAK,CAClE,OAAO,oDAAoD,CAC5D,CAAA;AAED,eAAO,MAAM,kDAAkD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9D,CAAA;AACD,MAAM,MAAM,4CAA4C,GACtD,iDAAiD,CAAA;AAEnD,MAAM,MAAM,iDAAiD,GAAG,CAAC,CAAC,KAAK,CACrE,OAAO,kDAAkD,CAC1D,CAAA;AAED,eAAO,MAAM,kEAAkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAE9E,CAAA;AACD,MAAM,MAAM,4DAA4D,GAAG,CAAC,CAAC,KAAK,CAChF,OAAO,kEAAkE,CAC1E,CAAA;AACD,MAAM,MAAM,iEAAiE,GAAG,CAAC,CAAC,KAAK,CACrF,OAAO,kEAAkE,CAC1E,CAAA"}
+{"version":3,"file":"image-generate.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-generate.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AAEpF,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAqB1B,eAAO,MAAM,IAAI,EAAE,cA6BlB,CAAA;AASD,eAAO,MAAM,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAgEtC,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;AAED,eAAO,MAAM,eAAe,EAAE,eAAe,CAC3C,OAAO,kDAAkD,EACzD,OAAO,kEAAkE,CAM1E,CAAA"}

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

@@ -1,9 +1,13 @@
+import { optionalWithV3Semantics } from "../lib/sdkZodOptional.js";
 import { z } from 'zod/v4';
-import { autoProviderDescription, interpolateRobot, robotBase, robotUse, } from "./_instructions-primitives.js";
+import { imageGenerateDefaultModelIdentifier, imageGenerateLegacyModelAlias, imageGenerateModelIdentifiers, } from "./_ai-models.js";
+import { autoProviderDescription, interpolateRobot, robotArtificialIntelligenceMeta, robotBase, robotParameterDocs, robotUse, } from "./_instructions-primitives.js";
+function formatEnglishModelList(values) {
+    const formattedValues = values.map((model) => `\`${model}\``);
+    return `${formattedValues.slice(0, -1).join(', ')}, and ${formattedValues.at(-1)}`;
+}
 export const meta = {
-    bytescount: 1,
-    discount_factor: 1,
-    discount_pct: 0,
+    ...robotArtificialIntelligenceMeta,
     example_code: {
         steps: {
             ':original': {
@@ -21,27 +25,14 @@ export const meta = {
             },
         },
     },
-    example_code_description: 'Inpaint an image by uploading an original image and a mask image, then use both files in /image/generate.',
-    minimum_charge: 0,
-    output_factor: 0.6,
+    example_code_description: 'Inpaint an image by uploading an original image and a mask image, then use both files in /image/generate:',
     purpose_sentence: 'generates images from text prompts using AI',
     purpose_verb: 'generate',
     purpose_word: 'generate',
     purpose_words: 'Generate images from text prompts',
-    service_slug: 'artificial-intelligence',
-    slot_count: 10,
     title: 'Generate images from text prompts',
-    typical_file_size_mb: 1.2,
-    typical_file_type: 'image',
     name: 'ImageGenerateRobot',
-    priceFactor: 1,
-    queueSlotCount: 10,
     minimumChargeUsd: 0.06,
-    isAllowedForUrlTransform: true,
-    trackOutputFileSize: true,
-    isInternal: false,
-    removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-    stage: 'ga',
 };
 // Internal documentation (for public docs, see transloadit.com/docs)
 //
@@ -71,47 +62,45 @@ For inpainting, provide both the source image and mask through \`use\`, typicall
 Best practice:
 - Tag source and mask inputs explicitly using \`as\` (or semantic upload field names)
 - Keep the prompt focused on what should change in the masked/transparent region
-- Leave the model/provider choice to the robot defaults unless you have a specific need
+- Leave the model choice to the robot defaults unless you have a specific need
 `),
-    model: z
-        .string()
-        .optional()
-        .describe('The AI model to use. Defaults to openai/gpt-image-2.5-flare. Supported models include flux-1.1-pro-ultra, flux-schnell, recraft-v3, google/nano-banana, google/nano-banana-2, google/nano-banana-pro, openai/gpt-image-2, openai/gpt-image-2.5-flare, openai/gpt-image-2.5-sunburst, and stability-ai/stable-diffusion-inpainting. The legacy alias gpt-image-2 is also accepted for backwards compatibility.'),
+    model: optionalWithV3Semantics(z
+        .string())
+        .describe(`The AI model to use. Defaults to \`${imageGenerateDefaultModelIdentifier}\`. Supported models include ${formatEnglishModelList(imageGenerateModelIdentifiers)}. The legacy alias \`${imageGenerateLegacyModelAlias}\` is also accepted for backwards compatibility.`),
     prompt: z
         .string()
         .describe('Prompt describing the desired image. For inpainting, describe what should appear in the masked/transparent region and that the rest should stay unchanged.'),
-    format: z
-        .enum(['jpeg', 'jpg', 'png', 'gif', 'webp', 'svg'])
-        .optional()
+    format: optionalWithV3Semantics(z
+        .enum(['jpeg', 'jpg', 'png', 'gif', 'webp', 'svg']))
         .describe('Output format. Defaults depend on model: png for Google and OpenAI models, svg for recraft-v3, jpeg for others. Google models currently return PNG only.'),
-    seed: z.number().optional().describe('Seed for the random number generator.'),
-    aspect_ratio: z
-        .string()
-        .optional()
+    seed: optionalWithV3Semantics(z.number()).describe(robotParameterDocs.seed.description),
+    aspect_ratio: optionalWithV3Semantics(z
+        .string())
         .describe('Requested output aspect ratio. For Google models, width/height can also be used and orientation is derived automatically when aspect_ratio is omitted.'),
-    height: z
-        .number()
-        .optional()
+    height: optionalWithV3Semantics(z
+        .number())
         .describe('Requested output height in pixels (mainly used by Google and OpenAI image models).'),
-    width: z
-        .number()
-        .optional()
+    width: optionalWithV3Semantics(z
+        .number())
         .describe('Requested output width in pixels (mainly used by Google and OpenAI image models).'),
-    style: z.string().optional().describe('Style of the generated image.'),
-    num_outputs: z
+    style: optionalWithV3Semantics(z.string()).describe('Style of the generated image.'),
+    num_outputs: optionalWithV3Semantics(z
         .number()
         .int()
         .min(1)
-        .max(10)
-        .optional()
+        .max(10))
         .describe('Number of output variants to generate (1-10).'),
 })
     .strict();
 export const robotImageGenerateInstructionsWithHiddenFieldsSchema = robotImageGenerateInstructionsSchema.extend({
     provider: z.string().default('auto').describe(autoProviderDescription),
-    result: z
-        .union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result])
-        .optional(),
+    result: optionalWithV3Semantics(z
+        .union([z.literal('debug'), robotImageGenerateInstructionsSchema.shape.result])),
 });
-export const interpolatableRobotImageGenerateInstructionsSchema = interpolateRobot(robotImageGenerateInstructionsWithHiddenFieldsSchema);
+export const interpolatableRobotImageGenerateInstructionsSchema = interpolateRobot(robotImageGenerateInstructionsSchema);
 export const interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema = interpolateRobot(robotImageGenerateInstructionsWithHiddenFieldsSchema);
+export const robotDefinition = {
+    meta,
+    interpolatable: interpolatableRobotImageGenerateInstructionsSchema,
+    interpolatableWithHiddenFields: interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema,
+};

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

@@ -1,15 +1,16 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts';
+import type { RobotDefinition, RobotMetaInput, RobotSchemaVariantTypes } from './_instructions-primitives.ts';
 import { z } from 'zod/v4';
 export declare const meta: RobotMetaInput;
 export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     result: z.ZodDefault<z.ZodBoolean>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
@@ -54,8 +55,8 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
-        none: "none";
         transparent: "transparent";
+        none: "none";
         black: "black";
         white: "white";
         red: "red";
@@ -81,15 +82,17 @@ export declare const robotImageMergeInstructionsSchema: z.ZodObject<{
     adaptive_filtering: z.ZodDefault<z.ZodBoolean>;
     quality: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>;
+export declare const robotDefinition: RobotDefinition<typeof robotImageMergeInstructionsSchema.shape>;
 export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     output_meta: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodBoolean>, z.ZodBoolean, z.ZodArray<z.ZodString>]>>;
+    user_meta: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     queue: z.ZodOptional<z.ZodEnum<{
         batch: "batch";
     }>>;
@@ -133,8 +136,8 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     cell_height: z.ZodOptional<z.ZodNumber>;
     border: z.ZodDefault<z.ZodNumber>;
     background: z.ZodDefault<z.ZodUnion<readonly [z.ZodString, z.ZodEnum<{
-        none: "none";
         transparent: "transparent";
+        none: "none";
         black: "black";
         white: "white";
         red: "red";
@@ -160,24 +163,22 @@ export declare const robotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObj
     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<{
+}, z.core.$strict>, interpolatableRobotImageMergeInstructionsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodPrefault<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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -196,12 +197,12 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         jpg: "jpg";
         png: "png";
         webp: "webp";
     }>]>>;
-    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    direction: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
         grid: "grid";
@@ -214,10 +215,10 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        none: "none";
+    border: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    background: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         transparent: "transparent";
+        none: "none";
         black: "black";
         white: "white";
         red: "red";
@@ -233,32 +234,30 @@ export declare const interpolatableRobotImageMergeInstructionsSchema: z.ZodObjec
     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]>>;
-    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    shuffle: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         basename: "basename";
         import_order: "import_order";
     }>]>>;
     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]>>;
-}, z.core.$strict>;
-export type InterpolatableRobotImageMergeInstructions = InterpolatableRobotImageMergeInstructionsInput;
-export type InterpolatableRobotImageMergeInstructionsInput = z.input<typeof interpolatableRobotImageMergeInstructionsSchema>;
-export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
+    adaptive_filtering: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    quality: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+}, z.core.$strict>, interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema: z.ZodObject<{
     interpolate: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
-        false: "false";
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>, z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<readonly [z.ZodBoolean, z.ZodEnum<{
         true: "true";
-    }>]>, z.ZodTransform<boolean, boolean | "false" | "true">>>]>>;
+        false: "false";
+    }>]>, z.ZodTransform<boolean, boolean | "true" | "false">>>]>>;
     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>]>]>>;
+    user_meta: z.ZodPrefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     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<{
+    force_accept: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    ignore_errors: z.ZodPrefault<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")[]>>]>>;
@@ -277,12 +276,12 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
         fields: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>]>>;
     robot: z.ZodLiteral<"/image/merge">;
-    format: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    format: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         jpg: "jpg";
         png: "png";
         webp: "webp";
     }>]>>;
-    direction: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    direction: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         vertical: "vertical";
         horizontal: "horizontal";
         grid: "grid";
@@ -295,10 +294,10 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     rows: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     cell_width: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
     cell_height: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    border: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    background: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
-        none: "none";
+    border: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    background: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodString, z.ZodUnion<[z.ZodString, z.ZodEnum<{
         transparent: "transparent";
+        none: "none";
         black: "black";
         white: "white";
         red: "red";
@@ -314,17 +313,23 @@ export declare const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSc
     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]>>;
-    sort_by: z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
+    shuffle: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    sort_by: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodEnum<{
         auto: "auto";
         basename: "basename";
         import_order: "import_order";
     }>]>>;
     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]>>]>>;
+    adaptive_filtering: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>;
+    quality: z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
+    result: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodUnion<[z.ZodString, z.ZodLiteral<"debug">]>, z.ZodPrefault<z.ZodUnion<[z.ZodString, z.ZodBoolean]>>]>>;
 }, z.core.$strict>;
-export type InterpolatableRobotImageMergeInstructionsWithHiddenFields = z.infer<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;
-export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = z.input<typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema>;
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>;
+export type RobotImageMergeInstructions = Instructions['output'];
+export type RobotImageMergeInstructionsWithHiddenFields = Instructions['hiddenOutput'];
+export type InterpolatableRobotImageMergeInstructions = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageMergeInstructionsInput = Instructions['interpolatableInput'];
+export type InterpolatableRobotImageMergeInstructionsWithHiddenFields = Instructions['interpolatableHiddenOutput'];
+export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = Instructions['interpolatableHiddenInput'];
+export {};
 //# sourceMappingURL=image-merge.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AAEnE,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAU1B,eAAO,MAAM,IAAI,EAAE,cAqClB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA2JnC,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"}
+{"version":3,"file":"image-merge.d.ts","sourceRoot":"","sources":["../../../src/v4/robots/image-merge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EACd,uBAAuB,EACxB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAa1B,eAAO,MAAM,IAAI,EAAE,cAsBlB,CAAA;AAED,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAuInC,CAAA;AAEX,eAAO,MAAM,eAAe,EAAE,eAAe,CAAC,OAAO,iCAAiC,CAAC,KAAK,CACtC,CAAA;AAEtD,eAAO,MACa,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBACnD,+CAA+C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAC/B,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAC9E,CAAA;AAEnB,KAAK,YAAY,GAAG,uBAAuB,CAAC,OAAO,eAAe,CAAC,CAAA;AAEnE,MAAM,MAAM,2BAA2B,GAAG,YAAY,CAAC,QAAQ,CAAC,CAAA;AAChE,MAAM,MAAM,2CAA2C,GAAG,YAAY,CAAC,cAAc,CAAC,CAAA;AACtF,MAAM,MAAM,yCAAyC,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAC3F,MAAM,MAAM,8CAA8C,GAAG,YAAY,CAAC,qBAAqB,CAAC,CAAA;AAChG,MAAM,MAAM,yDAAyD,GACnE,YAAY,CAAC,4BAA4B,CAAC,CAAA;AAC5C,MAAM,MAAM,8DAA8D,GACxE,YAAY,CAAC,2BAA2B,CAAC,CAAA"}