transloadit 4.14.0 → 5.0.1

package/src/alphalib/types/robots/image-facedetect.ts

@@ -1,12 +1,18 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  autoProviderDescription,
   awsGcpAiProviderSchema,
-  interpolateRobot,
+  createProcessingExample,
+  defineRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
+  robotParameterDocs,
   robotUse,
 } from './_instructions-primitives.ts'
 
@@ -34,44 +40,25 @@ export const imageFacedetectFaceCoordinatesSchema = z
 export type ImageFacedetectFaceCoordinates = z.infer<typeof imageFacedetectFaceCoordinatesSchema>
 
 export const meta: RobotMetaInput = {
-  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
@@ -92,11 +79,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)
@@ -105,7 +88,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).
@@ -143,32 +126,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:
 
@@ -177,35 +160,24 @@ 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 type RobotImageFacedetectInstructions = z.infer<
-  typeof robotImageFacedetectInstructionsSchema
->
-export type RobotImageFacedetectInstructionsWithHiddenFields = z.infer<
-  typeof robotImageFacedetectInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotImageFacedetectInstructionsSchema = interpolateRobot(
-  robotImageFacedetectInstructionsSchema,
-)
-export type InterpolatableRobotImageFacedetectInstructions =
-  InterpolatableRobotImageFacedetectInstructionsInput
-
-export type InterpolatableRobotImageFacedetectInstructionsInput = z.input<
-  typeof interpolatableRobotImageFacedetectInstructionsSchema
->
-
-export const interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema =
-  interpolateRobot(robotImageFacedetectInstructionsWithHiddenFieldsSchema)
-export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotImageFacedetectInstructionsSchema.shape> =
+  defineRobot(meta, robotImageFacedetectInstructionsSchema)
+
+export const {
+  withHiddenFields: robotImageFacedetectInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageFacedetectInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotImageFacedetectInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
+
+export type RobotImageFacedetectInstructions = Instructions['output']
+export type RobotImageFacedetectInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotImageFacedetectInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotImageFacedetectInstructionsInput =
+  Instructions['interpolatableInput']
+export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotImageFacedetectInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/image-generate.ts

@@ -1,18 +1,28 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import {
+  imageGenerateDefaultModelIdentifier,
+  imageGenerateLegacyModelAlias,
+  imageGenerateModelIdentifiers,
+} from './_ai-models.ts'
 import {
   autoProviderDescription,
   interpolateRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
+  robotParameterDocs,
   robotUse,
 } from './_instructions-primitives.ts'
 
+function formatEnglishModelList(values: readonly [string, string, ...string[]]): string {
+  const formattedValues = values.map((model) => `\`${model}\``)
+  return `${formattedValues.slice(0, -1).join(', ')}, and ${formattedValues.at(-1)}`
+}
+
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotArtificialIntelligenceMeta,
   example_code: {
     steps: {
       ':original': {
@@ -32,27 +42,14 @@ export const meta: RobotMetaInput = {
     },
   },
   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,
+    '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)
@@ -84,14 +81,14 @@ 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.',
+        `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()
@@ -104,7 +101,7 @@ Best practice:
       .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.'),
+    seed: z.number().optional().describe(robotParameterDocs.seed.description),
     aspect_ratio: z
       .string()
       .optional()
@@ -148,7 +145,7 @@ export type RobotImageGenerateInstructionsWithHiddenFields = z.infer<
 >
 
 export const interpolatableRobotImageGenerateInstructionsSchema = interpolateRobot(
-  robotImageGenerateInstructionsWithHiddenFieldsSchema,
+  robotImageGenerateInstructionsSchema,
 )
 export type InterpolatableRobotImageGenerateInstructions =
   InterpolatableRobotImageGenerateInstructionsInput
@@ -166,3 +163,13 @@ export type InterpolatableRobotImageGenerateInstructionsWithHiddenFields = z.inf
 export type InterpolatableRobotImageGenerateInstructionsWithHiddenFieldsInput = z.input<
   typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema
 >
+
+export const robotDefinition: RobotSchemaPair<
+  typeof interpolatableRobotImageGenerateInstructionsSchema,
+  typeof interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema
+> = {
+  meta,
+  interpolatable: interpolatableRobotImageGenerateInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotImageGenerateInstructionsWithHiddenFieldsSchema,
+}

package/src/alphalib/types/robots/image-merge.ts

@@ -1,19 +1,24 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
   color_without_alpha_with_named,
+  defineRobot,
+  imageAdaptiveFilteringSchema,
+  imageQualityValueSchema,
   inputSortBySchema,
-  interpolateRobot,
   robotBase,
+  robotImageProcessingMeta,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotImageProcessingMeta,
   example_code: {
     steps: {
       merged: {
@@ -28,25 +33,12 @@ export const meta: RobotMetaInput = {
   },
   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
@@ -133,14 +125,14 @@ A value of \`10\` would cause the images to have the largest gap between them, w
 
 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.
+When \`effect\` is \`mosaic\`, this value is used both as the outer canvas padding and as the gutter width between neighboring tiles.
 `),
     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. Set to \`none\` or \`transparent\` for a transparent canvas — requires \`format\` \`png\` or \`webp\` to preserve alpha.
+By default, the background of transparent images is changed to white. Set to \`none\` or \`transparent\` for a transparent canvas — set \`format\` to \`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/).
+For details about how to preserve transparency across all image types, see [this demo](/demos/image-processing/properly-preserve-transparency-across-all-image-types/).
 `),
     width: z
       .number()
@@ -188,52 +180,29 @@ The default of \`1.5\` leaves a subtle beige border along some edges. Use \`2.0\
 
 Has no effect on the \`mosaic\` style or on plain spritesheets.
 `),
-    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: z
-      .number()
-      .int()
-      .min(1)
-      .max(100)
-      .default(100)
-      .describe(`
+    adaptive_filtering: imageAdaptiveFilteringSchema,
+    quality: imageQualityValueSchema.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({
-    result: z
-      .union([z.literal('debug'), robotImageMergeInstructionsSchema.shape.result])
-      .optional(),
-  })
-
-export type RobotImageMergeInstructions = z.infer<typeof robotImageMergeInstructionsSchema>
-export type RobotImageMergeInstructionsWithHiddenFields = z.infer<
-  typeof robotImageMergeInstructionsWithHiddenFieldsSchema
->
-
-export const interpolatableRobotImageMergeInstructionsSchema = interpolateRobot(
-  robotImageMergeInstructionsSchema,
-)
-export type InterpolatableRobotImageMergeInstructions =
-  InterpolatableRobotImageMergeInstructionsInput
-
-export type InterpolatableRobotImageMergeInstructionsInput = z.input<
-  typeof interpolatableRobotImageMergeInstructionsSchema
->
-
-export const interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotImageMergeInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotImageMergeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageMergeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotImageMergeInstructionsSchema.shape> =
+  defineRobot(meta, robotImageMergeInstructionsSchema)
+
+export const {
+  withHiddenFields: robotImageMergeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageMergeInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotImageMergeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
+
+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']

package/src/alphalib/types/robots/image-ocr.ts

@@ -1,56 +1,42 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinition,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  autoProviderDescription,
   awsGcpAiProviderSchema,
+  createProcessingExample,
+  defineRobot,
   granularitySchema,
-  interpolateRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
+  robotParameterDocs,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      recognized: {
-        robot: '/image/ocr',
-        use: ':original',
-        provider: 'gcp',
-        format: 'text',
-      },
-    },
-  },
+  ...robotArtificialIntelligenceMeta,
+  example_code: createProcessingExample('recognized', '/image/ocr', {
+    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
@@ -61,53 +47,31 @@ With this <dfn>Robot</dfn> you can detect and extract text from images using opt
 
 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: awsGcpAiProviderSchema.describe(`
-${autoProviderDescription}
-
-Set this to \`"aws"\` or \`"gcp"\` to force a specific provider.
-
-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"\`.
-`),
+    provider: awsGcpAiProviderSchema.describe(robotParameterDocs.ocr_provider.description),
+    granularity: granularitySchema.describe(robotParameterDocs.ocr_granularity.description),
     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.
-`),
+      .describe(robotParameterDocs.ocr_format.description),
   })
   .strict()
 
-export const robotImageOcrInstructionsWithHiddenFieldsSchema =
-  robotImageOcrInstructionsSchema.extend({
-    result: z.union([z.literal('debug'), robotImageOcrInstructionsSchema.shape.result]).optional(),
-  })
-
-export type RobotImageOcrInstructions = z.infer<typeof robotImageOcrInstructionsSchema>
-export type RobotImageOcrInstructionsWithHiddenFields = z.infer<
-  typeof robotImageOcrInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinition<typeof robotImageOcrInstructionsSchema.shape> =
+  defineRobot(meta, robotImageOcrInstructionsSchema)
 
-export const interpolatableRobotImageOcrInstructionsSchema = interpolateRobot(
-  robotImageOcrInstructionsSchema,
-)
-export type InterpolatableRobotImageOcrInstructions = InterpolatableRobotImageOcrInstructionsInput
+export const {
+  withHiddenFields: robotImageOcrInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotImageOcrInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotImageOcrInstructionsInput = z.input<
-  typeof interpolatableRobotImageOcrInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotImageOcrInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotImageOcrInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotImageOcrInstructionsWithHiddenFieldsSchema
->
+export type RobotImageOcrInstructions = Instructions['output']
+export type RobotImageOcrInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotImageOcrInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotImageOcrInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotImageOcrInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']