transloadit 4.13.1 → 5.0.0

package/src/alphalib/types/robots/video-encode.ts

@@ -1,51 +1,35 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { stackVersions } from '../stackVersions.ts'
 import {
-  interpolateRobot,
+  createProcessingExample,
+  defineRobotWithHiddenFields,
   robotBase,
   robotUse,
+  robotVideoEncodingMeta,
   videoEncodeSpecificInstructionsSchema,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
-  example_code: {
-    steps: {
-      hevc_encoded: {
-        robot: '/video/encode',
-        use: ':original',
-        preset: 'hevc',
-      },
-    },
-  },
+  ...robotVideoEncodingMeta,
+  example_code: createProcessingExample('hevc_encoded', '/video/encode', {
+    preset: 'hevc',
+  }),
   example_code_description:
     'Transcode uploaded video to [HEVC](https://en.wikipedia.org/wiki/High_Efficiency_Video_Coding) (H.265):',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Video Encoding',
   purpose_sentence: 'encodes, resizes, applies watermarks to videos and animated GIFs',
   purpose_verb: 'transcode',
   purpose_word: 'transcode/resize/watermark',
   purpose_words: 'Transcode, resize, or watermark videos',
-  service_slug: 'video-encoding',
-  slot_count: 60,
   title: 'Transcode, resize, or watermark videos',
-  typical_file_size_mb: 80,
-  typical_file_type: 'video',
   uses_tools: ['ffmpeg'],
   name: 'VideoEncodeRobot',
-  priceFactor: 1,
-  queueSlotCount: 60,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  stage: 'ga',
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
 }
 
 export const robotVideoEncodeInstructionsSchema = robotBase
@@ -69,7 +53,7 @@ You can add text overlays to videos using FFmpeg's \`drawtext\` filter through t
       "use": ":original",
       "robot": "/video/encode",
       "preset": "empty",
-      "ffmpeg_stack": "{{stacks.ffmpeg.recommended_version}}",
+      "ffmpeg_stack": "${stackVersions.ffmpeg.recommendedVersion}",
       "ffmpeg": {
         "codec:a": "copy",
         "vf": "drawtext=text='My text overlay':fontcolor=white:fontsize=24:box=1:boxcolor=black@0.5:boxborderw=5:x=(w-text_w)/2:y=(h-text_h)/2"
@@ -80,7 +64,7 @@ You can add text overlays to videos using FFmpeg's \`drawtext\` filter through t
       "use": ":original",
       "robot": "/video/encode",
       "preset": "empty",
-      "ffmpeg_stack": "{{stacks.ffmpeg.recommended_version}}",
+      "ffmpeg_stack": "${stackVersions.ffmpeg.recommendedVersion}",
       "ffmpeg": {
         "codec:a": "copy",
         "vf": "drawtext=font='Times New Roman':text='My text overlay':fontcolor=white:fontsize=24:box=1:boxcolor=black@0.5:boxborderw=5:x=(w-text_w)/2:y=(h-text_h)/2"
@@ -101,7 +85,7 @@ You can add text overlays to videos using FFmpeg's \`drawtext\` filter through t
 - Preserve the source audio by setting \`"codec:a": "copy"\`.
 - Position text with the \`x\` and \`y\` expressions. The example above centers the text.
 
-See the live demo [here](/demos/video-encoding/add-text-overlay/).
+See the [live text overlay demo](/demos/video-encoding/add-text-overlay/).
 `),
     font_size: z.number().optional(),
     font_color: z.string().optional(),
@@ -109,37 +93,30 @@ See the live demo [here](/demos/video-encoding/add-text-overlay/).
   })
   .strict()
 
-export const robotVideoEncodeInstructionsWithHiddenFieldsSchema =
-  robotVideoEncodeInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoEncodeInstructionsSchema.shape.result])
-      .optional(),
-    chunked_transcoding: z.boolean().optional(),
-    freeze_detect: z.boolean().optional(),
-    realtime: z.boolean().optional(),
-  })
+const hiddenFields = {
+  chunked_transcoding: z.boolean().optional(),
+  freeze_detect: z.boolean().optional(),
+  realtime: z.boolean().optional(),
+}
 
-export type RobotVideoEncodeInstructions = z.infer<typeof robotVideoEncodeInstructionsSchema>
-export type RobotVideoEncodeInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoEncodeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotVideoEncodeInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotVideoEncodeInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotVideoEncodeInstructionsSchema = interpolateRobot(
-  robotVideoEncodeInstructionsSchema,
-)
-export type InterpolatableRobotVideoEncodeInstructions =
-  InterpolatableRobotVideoEncodeInstructionsInput
+export const {
+  withHiddenFields: robotVideoEncodeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoEncodeInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotVideoEncodeInstructionsInput = z.input<
-  typeof interpolatableRobotVideoEncodeInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoEncodeInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoEncodeInstructionsWithHiddenFieldsSchema
->
+export type RobotVideoEncodeInstructions = Instructions['output']
+export type RobotVideoEncodeInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoEncodeInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoEncodeInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoEncodeInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

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

@@ -1,18 +1,19 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type { RobotMetaInput, RobotSchemaPair } from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { videoGenerateDefaultModelIdentifier } from './_ai-models.ts'
 import {
   autoProviderDescription,
   interpolateRobot,
+  robotArtificialIntelligenceMeta,
   robotBase,
+  robotParameterDocs,
   robotUse,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotArtificialIntelligenceMeta,
   example_code: {
     steps: {
       generated_video: {
@@ -25,27 +26,16 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Generate a short video from a text prompt:',
-  minimum_charge: 0,
-  output_factor: 0.6,
   purpose_sentence: 'generates videos from text prompts using AI',
   purpose_verb: 'generate',
   purpose_word: 'generate',
   purpose_words: 'Generate videos from text prompts',
-  service_slug: 'artificial-intelligence',
-  slot_count: 10,
   title: 'Generate videos from text prompts',
   typical_file_size_mb: 50,
   typical_file_type: 'video',
   name: 'VideoGenerateRobot',
-  priceFactor: 1,
-  queueSlotCount: 10,
   minimumChargeUsd: 0.06,
-  isAllowedForUrlTransform: true,
-  trackOutputFileSize: true,
   applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotVideoGenerateInstructionsSchema = robotBase
@@ -55,10 +45,12 @@ export const robotVideoGenerateInstructionsSchema = robotBase
     model: z
       .string()
       .optional()
-      .describe('The AI model to use for video generation. Defaults to minimax/video-01.'),
+      .describe(
+        `The AI model to use for video generation. Defaults to ${videoGenerateDefaultModelIdentifier}.`,
+      ),
     prompt: z.string().describe('The prompt describing the desired video content.'),
     format: z.enum(['mp4', 'gif']).optional().describe('Format of the generated video.'),
-    seed: z.number().optional().describe('Seed for the random number generator.'),
+    seed: z.number().optional().describe(robotParameterDocs.seed.description),
     aspect_ratio: z.string().optional().describe('Aspect ratio of the generated video.'),
     height: z.number().optional().describe('Height of the generated video.'),
     width: z.number().optional().describe('Width of the generated video.'),
@@ -107,7 +99,7 @@ export type RobotVideoGenerateInstructionsWithHiddenFields = z.infer<
 >
 
 export const interpolatableRobotVideoGenerateInstructionsSchema = interpolateRobot(
-  robotVideoGenerateInstructionsWithHiddenFieldsSchema,
+  robotVideoGenerateInstructionsSchema,
 )
 export type InterpolatableRobotVideoGenerateInstructions =
   InterpolatableRobotVideoGenerateInstructionsInput
@@ -125,3 +117,13 @@ export type InterpolatableRobotVideoGenerateInstructionsWithHiddenFields = z.inf
 export type InterpolatableRobotVideoGenerateInstructionsWithHiddenFieldsInput = z.input<
   typeof interpolatableRobotVideoGenerateInstructionsWithHiddenFieldsSchema
 >
+
+export const robotDefinition: RobotSchemaPair<
+  typeof interpolatableRobotVideoGenerateInstructionsSchema,
+  typeof interpolatableRobotVideoGenerateInstructionsWithHiddenFieldsSchema
+> = {
+  meta,
+  interpolatable: interpolatableRobotVideoGenerateInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotVideoGenerateInstructionsWithHiddenFieldsSchema,
+}

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

@@ -1,22 +1,25 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
 import {
-  color_with_alpha,
+  defineRobotWithHiddenFields,
   httpUrlSchema,
   inputSortBySchema,
-  interpolateRobot,
   resize_strategy,
   robotBase,
   robotFFmpegVideo,
   robotUse,
+  robotVideoEncodingMeta,
+  videoBackgroundSchema,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  bytescount: 1,
-  discount_factor: 1,
-  discount_pct: 0,
+  ...robotVideoEncodingMeta,
   example_code: {
     steps: {
       merged: {
@@ -34,29 +37,14 @@ export const meta: RobotMetaInput = {
     },
   },
   example_code_description: 'Merge uploaded image and audio inputs into one video:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Video Encoding',
   purpose_sentence:
     'composes a new video by adding an audio track to existing still image(s) or video',
   purpose_verb: 'merge',
   purpose_word: 'merge',
   purpose_words: 'Merge video, audio, images into one video',
-  service_slug: 'video-encoding',
-  slot_count: 60,
   title: 'Merge video, audio, images into one video',
-  typical_file_size_mb: 80,
-  typical_file_type: 'video',
   uses_tools: ['ffmpeg'],
   name: 'VideoMergeRobot',
-  priceFactor: 1,
-  queueSlotCount: 60,
-  isAllowedForUrlTransform: false,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'ga',
 }
 
 export const robotVideoMergeInstructionsSchema = robotBase
@@ -67,11 +55,9 @@ export const robotVideoMergeInstructionsSchema = robotBase
     resize_strategy: resize_strategy.describe(`
 If the given width/height parameters are bigger than the input image's dimensions, then the \`resize_strategy\` determines how the image will be resized to match the provided width/height. See the [available resize strategies](/docs/topics/resize-strategies/).
 `),
-    background: color_with_alpha.default('#00000000').describe(`
-The background color of the resulting video the \`"rrggbbaa"\` format (red, green, blue, alpha) when used with the \`"pad"\` resize strategy. The default color is black.
-`),
+    background: videoBackgroundSchema,
     framerate: z
-      .union([z.number().int().min(1), z.string().regex(/^\d+(?:\/\d+)?$/)])
+      .union([z.number().int().min(1), z.string().regex(/^[0-9]+(?:\/[0-9]+)?$/u)])
       .default('1/5')
       .describe(`
 When merging images to generate a video this is the input framerate. A value of "1/5" means each image is given 5 seconds before the next frame appears (the inverse of a framerate of "5"). Likewise for "1/10", "1/20", etc. A value of "5" means there are 5 frames per second.
@@ -84,7 +70,8 @@ When merging images to generate a video this allows you to define how long (in s
 `),
     duration: z
       .number()
-      .default(5)
+      .nullable()
+      .default(null)
       .describe(`
 When merging images to generate a video or when merging audio and video this is the desired target duration in seconds. The float value can take one decimal digit. If you want all images to be displayed exactly once, then you can set the duration according to this formula: \`duration = numberOfImages / framerate\`. This also works for the inverse framerate values like \`1/5\`.
 
@@ -102,7 +89,8 @@ When merging a video and an audio file, and when merging images and an audio fil
       .boolean()
       .default(false)
       .describe(`
-  Determines whether the shorter media file should be looped to match the duration of the longer one. For example, if you merge a 1-minute video with a 3-minute audio file and enable this option, the video will play three times in a row to match the audio length.`),
+Determines whether the shorter media file should be looped to match the duration of the longer one. For example, if you merge a 1-minute video with a 3-minute audio file and enable this option, the video will play three times in a row to match the audio length.
+`),
     replace_audio: z
       .boolean()
       .default(false)
@@ -138,35 +126,28 @@ The duration of the transition effect in seconds. Only applies when \`transition
   })
   .strict()
 
-export const robotVideoMergeInstructionsWithHiddenFieldsSchema =
-  robotVideoMergeInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoMergeInstructionsSchema.shape.result])
-      .optional(),
-    turbo: z.boolean().optional(),
-  })
+const hiddenFields = {
+  turbo: z.boolean().optional(),
+}
 
-export type RobotVideoMergeInstructions = z.infer<typeof robotVideoMergeInstructionsSchema>
-export type RobotVideoMergeInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoMergeInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotVideoMergeInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotVideoMergeInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotVideoMergeInstructionsSchema = interpolateRobot(
-  robotVideoMergeInstructionsSchema,
-)
-export type InterpolatableRobotVideoMergeInstructions =
-  InterpolatableRobotVideoMergeInstructionsInput
+export const {
+  withHiddenFields: robotVideoMergeInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoMergeInstructionsSchema,
+  interpolatableWithHiddenFields: interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotVideoMergeInstructionsInput = z.input<
-  typeof interpolatableRobotVideoMergeInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoMergeInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoMergeInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoMergeInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoMergeInstructionsWithHiddenFieldsSchema
->
+export type RobotVideoMergeInstructions = Instructions['output']
+export type RobotVideoMergeInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoMergeInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoMergeInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoMergeInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoMergeInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']

package/src/alphalib/types/robots/video-ondemand.ts

@@ -1,18 +1,22 @@
-import type { RobotMetaInput } from './_instructions-primitives.ts'
+import type {
+  RobotDefinitionWithHiddenFields,
+  RobotMetaInput,
+  RobotSchemaVariantTypes,
+} from './_instructions-primitives.ts'
 
 import { z } from 'zod'
 
+import { stackVersions } from '../stackVersions.ts'
 import {
-  interpolateRobot,
+  defineRobotWithHiddenFields,
   robotBase,
   robotUse,
+  robotVideoEncodingMeta,
   videoEncodeSpecificInstructionsSchema,
 } from './_instructions-primitives.ts'
 
 export const meta: RobotMetaInput = {
-  discount_factor: 1,
-  discount_pct: 0,
-  bytescount: 1,
+  ...robotVideoEncodingMeta,
   example_code: {
     steps: {
       import: {
@@ -27,15 +31,15 @@ export const meta: RobotMetaInput = {
         variants: {
           '480p': {
             preset: 'hls/480p',
-            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+            ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
           },
           '720p': {
             preset: 'hls/720p',
-            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+            ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
           },
           '1080p': {
             preset: 'hls/1080p',
-            ffmpeg_stack: '{{ stacks.ffmpeg.recommended_version }}',
+            ffmpeg_stack: stackVersions.ffmpeg.recommendedVersion,
           },
         },
       },
@@ -47,29 +51,17 @@ export const meta: RobotMetaInput = {
   },
   example_code_description:
     'Enable streaming of a video stored on S3 in three variants (480p, 720p, 1080p) with on-demand encoding:',
-  minimum_charge: 0,
-  output_factor: 0.6,
-  override_lvl1: 'Video Encoding',
   purpose_sentence:
     'generates HTTP Live Streaming (HLS) playlists and segments on-demand for adaptive and cost-efficient playback',
   purpose_verb: 'stream',
   purpose_word: 'stream',
   purpose_words: 'Stream videos with on-demand encoding',
-  service_slug: 'video-encoding',
-  slot_count: 60,
   title: 'Stream videos with on-demand encoding',
   typical_file_size_mb: 300,
-  typical_file_type: 'video',
   name: 'VideoOndemandRobot',
-  priceFactor: 1,
-  queueSlotCount: 60,
   downloadInputFiles: false,
   isAllowedForUrlTransform: true,
-  trackOutputFileSize: true,
-  applyCommunityPlanMediaTrim: true,
-  isInternal: false,
-  removeJobResultFilesFromDiskRightAfterStoringOnS3: false,
-  stage: 'beta',
+  stage: 'ga',
 }
 
 export const robotVideoOndemandInstructionsSchema = robotBase
@@ -115,48 +107,42 @@ export const robotVideoOndemandInstructionsSchema = robotBase
   })
   .strict()
 
-export const robotVideoOndemandInstructionsWithHiddenFieldsSchema =
-  robotVideoOndemandInstructionsSchema.extend({
-    result: z
-      .union([z.literal('debug'), robotVideoOndemandInstructionsSchema.shape.result])
-      .optional(),
-    cdn_required_bypass: z
-      .boolean()
-      .optional()
-      .default(false)
-      .describe(
-        'Internal parameter that indicates whether `cdn=required` should be added to the URLs in playlists. Useful for testing with URL Transform directly and not through Smart CDN.',
-      ),
-    url_transform_format: z
-      .boolean()
-      .optional()
-      .default(false)
-      .describe(
-        'Internal parameter that indicates whether the URLs in playlists should use the Smart CDN or the URL Transform format.',
-      ),
-  })
+const hiddenFields = {
+  cdn_required_bypass: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe(
+      'Internal parameter that indicates whether `cdn=required` should be added to the URLs in playlists. Useful for testing with URL Transform directly and not through Smart CDN.',
+    ),
+  url_transform_format: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe(
+      'Internal parameter that indicates whether the URLs in playlists should use the Smart CDN or the URL Transform format.',
+    ),
+}
 
-export type RobotVideoOndemandInstructions = z.infer<typeof robotVideoOndemandInstructionsSchema>
-export type RobotVideoOndemandInstructionsWithHiddenFields = z.infer<
-  typeof robotVideoOndemandInstructionsWithHiddenFieldsSchema
->
+export const robotDefinition: RobotDefinitionWithHiddenFields<
+  typeof robotVideoOndemandInstructionsSchema.shape,
+  typeof hiddenFields
+> = defineRobotWithHiddenFields(meta, robotVideoOndemandInstructionsSchema, hiddenFields)
 
-export const interpolatableRobotVideoOndemandInstructionsSchema = interpolateRobot(
-  robotVideoOndemandInstructionsSchema,
-)
-export type InterpolatableRobotVideoOndemandInstructions =
-  InterpolatableRobotVideoOndemandInstructionsInput
+export const {
+  withHiddenFields: robotVideoOndemandInstructionsWithHiddenFieldsSchema,
+  interpolatable: interpolatableRobotVideoOndemandInstructionsSchema,
+  interpolatableWithHiddenFields:
+    interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema,
+} = robotDefinition
 
-export type InterpolatableRobotVideoOndemandInstructionsInput = z.input<
-  typeof interpolatableRobotVideoOndemandInstructionsSchema
->
+type Instructions = RobotSchemaVariantTypes<typeof robotDefinition>
 
-export const interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema = interpolateRobot(
-  robotVideoOndemandInstructionsWithHiddenFieldsSchema,
-)
-export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFields = z.infer<
-  typeof interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema
->
-export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFieldsInput = z.input<
-  typeof interpolatableRobotVideoOndemandInstructionsWithHiddenFieldsSchema
->
+export type RobotVideoOndemandInstructions = Instructions['output']
+export type RobotVideoOndemandInstructionsWithHiddenFields = Instructions['hiddenOutput']
+export type InterpolatableRobotVideoOndemandInstructions = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoOndemandInstructionsInput = Instructions['interpolatableInput']
+export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFields =
+  Instructions['interpolatableHiddenOutput']
+export type InterpolatableRobotVideoOndemandInstructionsWithHiddenFieldsInput =
+  Instructions['interpolatableHiddenInput']